diff --git a/src/Generator/ApiData.cs b/src/Generator/ApiData.cs
index ad25df8..475f770 100644
--- a/src/Generator/ApiData.cs
+++ b/src/Generator/ApiData.cs
@@ -57,46 +57,6 @@ public class ApiParameter
     public List<object> Attrs { get; set; } = new();
 }
 
-public class ApiFunction
-{
-    public string Name { get; set; }
-    public bool SetLastError { get; set; }
-    public string DllImport { get; set; }
-    public ApiDataType ReturnType { get; set; }
-    public List<object> ReturnAttrs { get; set; }
-
-    public IList<ApiParameter> Params { get; set; } = new List<ApiParameter>();
-    public List<object> Attrs { get; set; }
-
-    private string _toString = default;
-
-    public override string ToString()
-    {
-        if (string.IsNullOrEmpty(_toString))
-        {
-            StringBuilder builder = new();
-            builder.Append(ReturnType.Name).Append(' ');
-            builder.Append(Name).Append('(');
-            int parameterIndex = 0;
-            foreach (var parameter in Params)
-            {
-                // TODO: Handle PointerTo, Array etc
-                builder.Append(parameter.Type.Name).Append(' ').Append(parameter.Name);
-                if (parameterIndex < Params.Count - 1)
-                {
-                    builder.Append(", ");
-                }
-                parameterIndex++;
-            }
-
-            builder.Append(')');
-            _toString = builder.ToString();
-        }
-
-        return _toString;
-    }
-}
-
 public class ApiType
 {
     public string Name { get; set; }
@@ -118,18 +78,19 @@ public class ApiType
     // Com
     public string Guid { get; set; }
     public ApiDataType Interface { get; set; }
-    public IList<ApiFunction> Methods { get; set; } = new List<ApiFunction>();
+    public IList<ApiType> Methods { get; set; } = new List<ApiType>();
 
     // Function
     public bool SetLastError { get; set; }
     public ApiDataType ReturnType { get; set; }
     public List<object> ReturnAttrs { get; set; }
     public IList<ApiParameter> Params { get; set; } = new List<ApiParameter>();
+    public string DllImport { get; set; }
 }
 
 public sealed class ApiData
 {
     public ApiDataConstant[] Constants { get; set; }
     public ApiType[] Types { get; set; }
-    public ApiFunction[] Functions { get; set; }
+    public ApiType[] Functions { get; set; }
 }
diff --git a/src/Generator/CodeWriter.cs b/src/Generator/CodeWriter.cs
index 0552c19..80f97ff 100644
--- a/src/Generator/CodeWriter.cs
+++ b/src/Generator/CodeWriter.cs
@@ -62,10 +62,15 @@ public sealed class CodeWriter : IDisposable
 
     public void Dispose()
     {
-        string content = _builder.ToString();
-        File.WriteAllText(_fileName, content);
+        if (string.IsNullOrEmpty(_fileName) == false)
+        {
+            string content = _builder.ToString();
+            File.WriteAllText(_fileName, content);
+        }
     }
 
+    public override string ToString() => _builder.ToString();
+
     public void Write(char chr)
     {
         WriteIndented(chr);
diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs
index 294c2fb..ed56a25 100644
--- a/src/Generator/Program.cs
+++ b/src/Generator/Program.cs
@@ -2,7 +2,9 @@
 // Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
 
 using System.ComponentModel.DataAnnotations;
+using System.Data.Common;
 using System.Globalization;
+using System.Reflection;
 using System.Reflection.Metadata;
 using System.Text;
 using Newtonsoft.Json;
@@ -25,9 +27,8 @@ public static class Program
         "Graphics.Direct2D.Common.json",
         "Graphics.Imaging.json",
         "Graphics.DirectWrite.json",
-        //"Graphics.Direct2D.json",
-
-        //"Graphics.Imaging.D2D.json",
+        "Graphics.Direct2D.json",
+        "Graphics.Imaging.D2D.json",
     };
 
     private static readonly Dictionary<string, string> s_csNameMappings = new()
@@ -103,6 +104,10 @@ public static class Program
 
         { "Graphics.Imaging.WICRect", "System.Drawing.Rectangle" },
 
+        { "Graphics.Direct2D.Matrix4x3F", "Win32.Graphics.Direct2D.Common.Matrix4x3" },
+        { "Graphics.Direct2D.Matrix4x4F", "Matrix4x4" },
+        { "Graphics.Direct2D.Matrix5x4F", "Win32.Graphics.Direct2D.Common.Matrix5x4" },
+
         // TODO: Understand those ->
         { "Foundation.RECT", "RawRect" },
         { "Foundation.RECTL", "RawRect" },
@@ -865,7 +870,7 @@ public static class Program
 
     private static readonly HashSet<string> s_visitedEnums = new();
     private static readonly HashSet<string> s_visitedStructs = new();
-    private static readonly Dictionary<string, List<KeyValuePair<ApiFunction, string>>> s_visitedComTypes = new();
+    private static readonly Dictionary<string, List<KeyValuePair<ApiType, string>>> s_visitedComTypes = new();
 
     private static bool s_generateUnmanagedDocs = true;
 
@@ -1113,7 +1118,7 @@ public static class Program
                 regionWritten = true;
             }
 
-            GenerateStruct(writer, structType);
+            GenerateStruct(api, writer, structType);
 
             s_visitedStructs.Add($"{writer.Api}.{structType.Name}");
         }
@@ -1146,7 +1151,7 @@ public static class Program
                 regionWritten = true;
             }
 
-            GenerateStruct(writer, structType);
+            GenerateStruct(api, writer, structType);
 
             s_visitedStructs.Add($"{writer.Api}.{structType.Name}");
         }
@@ -1181,7 +1186,7 @@ public static class Program
             }
 
             // Generate methods
-            List<KeyValuePair<ApiFunction, string>> methodsToGenerate = new();
+            List<KeyValuePair<ApiType, string>> methodsToGenerate = new();
             ApiType iterateType = comType;
             while (iterateType.Interface != null
                 && iterateType.Interface.Name != "IUnknown"
@@ -1193,8 +1198,12 @@ public static class Program
 
                 if (iterateType != null)
                 {
-                    foreach (ApiFunction method in iterateType.Methods)
+                    foreach (ApiType method in iterateType.Methods)
                     {
+                        // Until we add Storage.Xps.Printing.IPrintDocumentPackageTarget
+                        if (method.Name == "CreatePrintControl")
+                            continue;
+
                         methodsToGenerate.Add(new(method, iterateType.Name));
                     }
                 }
@@ -1211,8 +1220,12 @@ public static class Program
                 }
             }
 
-            foreach (ApiFunction method in comType.Methods)
+            foreach (ApiType method in comType.Methods)
             {
+                // Until we add Storage.Xps.Printing.IPrintDocumentPackageTarget
+                if (method.Name == "CreatePrintControl")
+                    continue;
+
                 methodsToGenerate.Add(new(method, comType.Name));
             }
 
@@ -1234,7 +1247,7 @@ public static class Program
         writer.WriteLine($"#region Functions");
         using (writer.PushBlock($"public static unsafe partial class Apis"))
         {
-            foreach (ApiFunction function in api.Functions)
+            foreach (ApiType function in api.Functions)
             {
                 if (function.Name.StartsWith("D3DX11") ||
                     function.Name == "D3DDisassemble11Trace")
@@ -1242,7 +1255,7 @@ public static class Program
                     continue;
                 }
 
-                WriteFunction(writer, api, function);
+                WriteFunction(writer, api, function, string.Empty, false);
                 writer.WriteLine();
             }
         }
@@ -1250,7 +1263,12 @@ public static class Program
         writer.WriteLine($"#endregion Functions");
     }
 
-    private static void WriteFunction(CodeWriter writer, ApiData api, ApiFunction function)
+    private static void WriteFunction(
+        CodeWriter writer,
+        ApiData api,
+        ApiType function,
+        string functionName,
+        bool asCallback)
     {
         string returnType = GetTypeName(function.ReturnType);
         string functionSuffix = string.Empty;
@@ -1303,7 +1321,13 @@ public static class Program
                 }
             }
 
-            argumentBuilder.Append(parameterType).Append(' ').Append(parameterName);
+            argumentBuilder.Append(parameterType);
+
+            if (asCallback == false)
+            {
+                argumentBuilder.Append(' ').Append(parameterName);
+            }
+
             if (isOptional == true)
             {
                 //argumentBuilder.Append(" = default");
@@ -1323,7 +1347,21 @@ public static class Program
         }
 
         string argumentsString = argumentBuilder.ToString();
-        writer.Write($"public {functionSuffix}{returnType} {function.Name}({argumentsString})");
+        if (string.IsNullOrEmpty(functionName))
+        {
+            functionName = function.Name;
+        }
+
+        writer.Write("public ");
+        if (asCallback)
+        {
+            writer.Write($"unsafe delegate* unmanaged[Stdcall]<{argumentsString}, {returnType}> {functionName}");
+        }
+        else
+        {
+            writer.Write($"{functionSuffix}{returnType} {functionName}({argumentsString})");
+        }
+
         writer.WriteLine(";");
     }
 
@@ -1480,7 +1518,7 @@ public static class Program
         return enumValueName;
     }
 
-    private static void GenerateStruct(CodeWriter writer, ApiType structType, bool nestedType = false)
+    private static void GenerateStruct(ApiData api, CodeWriter writer, ApiType structType, bool nestedType = false)
     {
         string csTypeName;
         string structPrefix = string.Empty;
@@ -1516,11 +1554,6 @@ public static class Program
             writer.WriteLine("[StructLayout(LayoutKind.Explicit)]");
         }
 
-        if (structType.Name == "D2D_MATRIX_3X2_F")
-        {
-
-        }
-
         using (writer.PushBlock($"public partial struct {csTypeName}"))
         {
             int fieldIndex = 0;
@@ -1542,7 +1575,24 @@ public static class Program
                     fieldValueName = "Mask";
                 }
 
-                string fieldTypeName = GetTypeName(field.Type);
+                if (structType.Name == "D2D1_LAYER_PARAMETERS")
+                {
+                }
+
+                bool asPointer = false;
+                if (field.Type.Kind == "ApiRef")
+                {
+                    string apiName = GetApiName(field.Type);
+                    string fullTypeName = $"{apiName}.{field.Type.Name}";
+
+                    if (s_visitedComTypes.ContainsKey(fullTypeName) ||
+                        api.Types.Any(item => item.Name == field.Type.Name && item.Kind.ToLowerInvariant() == "com"))
+                    {
+                        asPointer = true;
+                    }
+                }
+
+                string fieldTypeName = GetTypeName(field.Type, asPointer);
 
                 writer.WriteLine($"/// <include file='../{writer.DocFileName}.xml' path='doc/member[@name=\"{structType.Name}::{field.Name}\"]/*' />");
 
@@ -1616,20 +1666,28 @@ public static class Program
                 else
                 {
                     string unsafePrefix = string.Empty;
-                    fieldTypeName = NormalizeTypeName(writer.Api, fieldTypeName);
-                    if (fieldTypeName.EndsWith("*"))
+
+                    if (field.Type.TargetKind == "FunctionPointer")
                     {
-                        unsafePrefix += "unsafe ";
+                        ApiType functionType = api.Types.First(item => item.Name == field.Type.Name && item.Kind == "FunctionPointer");
+                        WriteFunction(writer, api, functionType, field.Name, true);
                     }
-
-                    if (isUnion)
+                    else
                     {
-                        writer.WriteLine("[FieldOffset(0)]");
+                        fieldTypeName = NormalizeTypeName(writer.Api, fieldTypeName);
+                        if (fieldTypeName.EndsWith("*"))
+                        {
+                            unsafePrefix += "unsafe ";
+                        }
+
+                        if (isUnion)
+                        {
+                            writer.WriteLine("[FieldOffset(0)]");
+                        }
+
+                        fieldValueName = CleanupName(fieldValueName);
+                        writer.WriteLine($"public {unsafePrefix}{fieldTypeName} {fieldValueName};");
                     }
-
-                    fieldValueName = CleanupName(fieldValueName);
-
-                    writer.WriteLine($"public {unsafePrefix}{fieldTypeName} {fieldValueName};");
                 }
 
                 if (fieldIndex < structType.Fields.Length - 1)
@@ -1713,7 +1771,7 @@ public static class Program
 
                 foreach (ApiType nestedTypeToGenerate in structType.NestedTypes)
                 {
-                    GenerateStruct(writer, nestedTypeToGenerate, true);
+                    GenerateStruct(api, writer, nestedTypeToGenerate, true);
                 }
             }
         }
@@ -1725,7 +1783,7 @@ public static class Program
         ApiData api,
         CodeWriter writer,
         ApiType comType,
-        List<KeyValuePair<ApiFunction, string>> methodsToGenerate)
+        List<KeyValuePair<ApiType, string>> methodsToGenerate)
     {
         string csTypeName = comType.Name;
 
@@ -1812,14 +1870,14 @@ public static class Program
             }
 
             bool needNewLine = false;
-            foreach (KeyValuePair<ApiFunction, string> methodPair in methodsToGenerate)
+            foreach (KeyValuePair<ApiType, string> methodPair in methodsToGenerate)
             {
                 if (needNewLine)
                 {
                     writer.WriteLine();
                 }
 
-                ApiFunction method = methodPair.Key;
+                ApiType method = methodPair.Key;
                 string docName = methodPair.Value;
 
                 // TODO: Handle inherit
@@ -2308,6 +2366,10 @@ public static class Program
             {
                 return "Rate" + prettyName;
             }
+            else if (enumPrefix.Contains("_LEVEL"))
+            {
+                return "Level_" + prettyName;
+            }
 
             return "_" + prettyName;
         }
@@ -2386,7 +2448,8 @@ public static class Program
         if (dataType.Kind == "ApiRef")
         {
             string apiName = GetApiName(dataType);
-            string typeName = GetTypeName($"{apiName}.{dataType.Name}");
+            string fullTypeName = $"{apiName}.{dataType.Name}";
+            string typeName = GetTypeName(fullTypeName);
             return asPointer ? typeName + "*" : typeName;
         }
         else if (dataType.Kind == "Array")
diff --git a/src/Vortice.Win32/Generated/Graphics/Direct2D.cs b/src/Vortice.Win32/Generated/Graphics/Direct2D.cs
new file mode 100644
index 0000000..1d7d4bd
--- /dev/null
+++ b/src/Vortice.Win32/Generated/Graphics/Direct2D.cs
@@ -0,0 +1,28756 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+using System;
+using System.Numerics;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+
+#if !NET6_0_OR_GREATER
+using MemoryMarshal = Win32.MemoryMarshal;
+#endif
+
+namespace Win32.Graphics.Direct2D;
+
+public static partial class Apis
+{
+	public const float D2D1_DEFAULT_FLATTENING_TOLERANCE = 0.25f;
+	public static ref readonly Guid CLSID_D2D12DAffineTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x85, 0x74, 0xA9, 0x6A,
+				0x54, 0x63,
+				0xFC, 0x4C,
+				0x90,
+				0x8C,
+				0xE4,
+				0xA7,
+				0x4F,
+				0x62,
+				0xC9,
+				0x6C
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D13DPerspectiveTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x0B, 0x4D, 0x84, 0xC2,
+				0x86, 0x3D,
+				0xE7, 0x46,
+				0x85,
+				0xBA,
+				0x52,
+				0x6C,
+				0x92,
+				0x40,
+				0xF3,
+				0xFB
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D13DTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x04, 0x7B, 0x46, 0xE8,
+				0x61, 0xEC,
+				0x8A, 0x4B,
+				0xB5,
+				0xDE,
+				0xD4,
+				0xD7,
+				0x3D,
+				0xEB,
+				0xEA,
+				0x5A
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1ArithmeticComposite
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x37, 0x14, 0x15, 0xFC,
+				0x9A, 0x04,
+				0x84, 0x47,
+				0xA2,
+				0x4A,
+				0xF1,
+				0xC4,
+				0xDA,
+				0xF2,
+				0x09,
+				0x87
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Atlas
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE4, 0x2B, 0x3E, 0x91,
+				0xCF, 0xFD,
+				0xE2, 0x4F,
+				0xA5,
+				0xF0,
+				0x24,
+				0x54,
+				0xF1,
+				0x4F,
+				0xF4,
+				0x08
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1BitmapSource
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4D, 0xC2, 0xB6, 0x5F,
+				0xDD, 0xC6,
+				0x31, 0x42,
+				0x94,
+				0x04,
+				0x50,
+				0xF4,
+				0xD5,
+				0xC3,
+				0x25,
+				0x2D
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Blend
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x7B, 0xB7, 0xC5, 0x81,
+				0xF8, 0x13,
+				0xDD, 0x4C,
+				0xAD,
+				0x20,
+				0xC8,
+				0x90,
+				0x54,
+				0x7A,
+				0xC6,
+				0x5D
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Border
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC0, 0x49, 0x2D, 0x2A,
+				0xCF, 0x4A,
+				0xC7, 0x43,
+				0x8C,
+				0x6A,
+				0x7C,
+				0x4A,
+				0x27,
+				0x87,
+				0x4D,
+				0x27
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Brightness
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x1E, 0x8D, 0xEA, 0x8C,
+				0xB0, 0x77,
+				0x86, 0x49,
+				0xB3,
+				0xB9,
+				0x2F,
+				0x0C,
+				0x0E,
+				0xAE,
+				0x78,
+				0x87
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1ColorManagement
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4C, 0x52, 0x28, 0x1A,
+				0xD6, 0xFD,
+				0xA4, 0x4A,
+				0xAE,
+				0x8F,
+				0x83,
+				0x7E,
+				0xB8,
+				0x26,
+				0x7B,
+				0x37
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1ColorMatrix
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD6, 0x03, 0x1F, 0x92,
+				0x1C, 0x64,
+				0xDF, 0x47,
+				0x85,
+				0x2D,
+				0xB4,
+				0xBB,
+				0x61,
+				0x53,
+				0xAE,
+				0x11
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Composite
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x51, 0x9F, 0xFC, 0x48,
+				0xAC, 0xF6,
+				0xF1, 0x48,
+				0x8B,
+				0x58,
+				0x3B,
+				0x28,
+				0xAC,
+				0x46,
+				0xF7,
+				0x6D
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1ConvolveMatrix
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x08, 0x8C, 0x7F, 0x40,
+				0x33, 0x55,
+				0x31, 0x43,
+				0xA3,
+				0x41,
+				0x23,
+				0xCC,
+				0x38,
+				0x77,
+				0x84,
+				0x3E
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Crop
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x10, 0x71, 0x3F, 0xE2,
+				0x9A, 0x0E,
+				0x24, 0x43,
+				0xAF,
+				0x47,
+				0x6A,
+				0x2C,
+				0x0C,
+				0x46,
+				0xF3,
+				0x5B
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1DirectionalBlur
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA6, 0x19, 0x43, 0x17,
+				0xE9, 0x58,
+				0xB2, 0x49,
+				0xBB,
+				0x63,
+				0xCA,
+				0xF2,
+				0xC8,
+				0x11,
+				0xA3,
+				0xDB
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1DiscreteTransfer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xCD, 0x6F, 0x86, 0x90,
+				0x8E, 0x48,
+				0x4B, 0x45,
+				0xAF,
+				0x06,
+				0xE5,
+				0x04,
+				0x1B,
+				0x66,
+				0xC3,
+				0x6C
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1DisplacementMap
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x64, 0x83, 0xC4, 0xED,
+				0x17, 0x04,
+				0x11, 0x41,
+				0x94,
+				0x50,
+				0x43,
+				0x84,
+				0x5F,
+				0xA9,
+				0xF8,
+				0x90
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1DistantDiffuse
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x62, 0xFD, 0x7E, 0x3E,
+				0x2D, 0xA3,
+				0xD4, 0x46,
+				0xA8,
+				0x3C,
+				0x52,
+				0x78,
+				0x88,
+				0x9A,
+				0xC9,
+				0x54
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1DistantSpecular
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE5, 0x1E, 0x8C, 0x42,
+				0xB8, 0x77,
+				0x50, 0x44,
+				0x8A,
+				0xB5,
+				0x72,
+				0x21,
+				0x9C,
+				0x21,
+				0xAB,
+				0xDA
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1DpiCompensation
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC7, 0xC5, 0x26, 0x6C,
+				0xE0, 0x34,
+				0xFC, 0x46,
+				0x9C,
+				0xFD,
+				0xE5,
+				0x82,
+				0x37,
+				0x06,
+				0xE2,
+				0x28
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Flood
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x20, 0x3C, 0xC2, 0x61,
+				0x69, 0xAE,
+				0x8E, 0x4D,
+				0x94,
+				0xCF,
+				0x50,
+				0x07,
+				0x8D,
+				0xF6,
+				0x38,
+				0xF2
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1GammaTransfer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC4, 0x44, 0x94, 0x40,
+				0x19, 0xC4,
+				0xA0, 0x41,
+				0xB0,
+				0xC1,
+				0x8C,
+				0xD0,
+				0xC0,
+				0xA1,
+				0x8E,
+				0x42
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1GaussianBlur
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x69, 0x6D, 0xEB, 0x1F,
+				0xE6, 0x2F,
+				0xC9, 0x4A,
+				0x8C,
+				0x58,
+				0x1D,
+				0x7F,
+				0x93,
+				0xE7,
+				0xA6,
+				0xA5
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Scale
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x69, 0x93, 0xAF, 0x9D,
+				0x46, 0x38,
+				0x0E, 0x4D,
+				0xA4,
+				0x4E,
+				0x0C,
+				0x60,
+				0x79,
+				0x34,
+				0xA5,
+				0xD7
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Histogram
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD0, 0xB7, 0x1D, 0x88,
+				0xEE, 0xF7,
+				0x4D, 0x4D,
+				0xA6,
+				0xD2,
+				0x46,
+				0x97,
+				0xAC,
+				0xC6,
+				0x6E,
+				0xE8
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1HueRotation
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xEC, 0x58, 0x44, 0x0F,
+				0x32, 0x4B,
+				0x1B, 0x49,
+				0x9E,
+				0x85,
+				0xBD,
+				0x73,
+				0xF4,
+				0x4D,
+				0x3E,
+				0xB6
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1LinearTransfer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xFD, 0xC8, 0x47, 0xAD,
+				0xEF, 0x63,
+				0xCC, 0x4A,
+				0x9B,
+				0x51,
+				0x67,
+				0x97,
+				0x9C,
+				0x03,
+				0x6C,
+				0x06
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1LuminanceToAlpha
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xB7, 0x1A, 0x25, 0x41,
+				0xEB, 0x0B,
+				0xF8, 0x46,
+				0x9D,
+				0xA7,
+				0x59,
+				0xE9,
+				0x3F,
+				0xCC,
+				0xE5,
+				0xDE
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Morphology
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x0D, 0xC4, 0xE6, 0xEA,
+				0x6A, 0x62,
+				0x2D, 0x4C,
+				0xBF,
+				0xCB,
+				0x39,
+				0x10,
+				0x01,
+				0xAB,
+				0xE2,
+				0x02
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1OpacityMetadata
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x6A, 0x00, 0x53, 0x6C,
+				0x50, 0x44,
+				0x99, 0x41,
+				0xAA,
+				0x5B,
+				0xAD,
+				0x16,
+				0x56,
+				0xFE,
+				0xCE,
+				0x5E
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1PointDiffuse
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC3, 0x03, 0xE3, 0xB9,
+				0x8C, 0xC0,
+				0x91, 0x4F,
+				0x8B,
+				0x7B,
+				0x38,
+				0x65,
+				0x6B,
+				0xC4,
+				0x8C,
+				0x20
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1PointSpecular
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x26, 0xCA, 0xC3, 0x09,
+				0xE2, 0x3A,
+				0x09, 0x4F,
+				0x9E,
+				0xBC,
+				0xED,
+				0x38,
+				0x65,
+				0xD5,
+				0x3F,
+				0x22
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Premultiply
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x19, 0xB4, 0xEA, 0x06,
+				0xED, 0xDE,
+				0x18, 0x40,
+				0x80,
+				0xD2,
+				0x3E,
+				0x1D,
+				0x47,
+				0x1A,
+				0xDE,
+				0xB2
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Saturation
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xCF, 0xD9, 0xB2, 0x5C,
+				0x7D, 0x32,
+				0x9F, 0x45,
+				0xA0,
+				0xCE,
+				0x40,
+				0xC0,
+				0xB2,
+				0x08,
+				0x6B,
+				0xF7
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Shadow
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x61, 0xA3, 0x7E, 0xC6,
+				0x63, 0x18,
+				0x69, 0x4E,
+				0x89,
+				0xDB,
+				0x69,
+				0x5D,
+				0x3E,
+				0x9A,
+				0x5B,
+				0x6B
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1SpotDiffuse
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x05, 0x11, 0x8A, 0x81,
+				0x32, 0x79,
+				0xF4, 0x44,
+				0xAA,
+				0x86,
+				0x08,
+				0xAE,
+				0x7B,
+				0x2F,
+				0x2C,
+				0x93
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1SpotSpecular
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x1E, 0x42, 0xAE, 0xED,
+				0x54, 0x76,
+				0x37, 0x4A,
+				0x9D,
+				0xB8,
+				0x71,
+				0xAC,
+				0xC1,
+				0xBE,
+				0xB3,
+				0xC1
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1TableTransfer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC3, 0x18, 0xF8, 0x5B,
+				0x43, 0x5E,
+				0xCB, 0x48,
+				0xB6,
+				0x31,
+				0x86,
+				0x83,
+				0x96,
+				0xD6,
+				0xA1,
+				0xD4
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Tile
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x38, 0x41, 0x78, 0xB0,
+				0x76, 0x3B,
+				0xC5, 0x4B,
+				0xB1,
+				0x3B,
+				0x0F,
+				0xA2,
+				0xAD,
+				0x02,
+				0x65,
+				0x9F
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Turbulence
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xAE, 0xB6, 0x2B, 0xCF,
+				0x9A, 0x88,
+				0xD7, 0x4A,
+				0xBA,
+				0x29,
+				0xA2,
+				0xFD,
+				0x73,
+				0x2C,
+				0x9F,
+				0xC9
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1UnPremultiply
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x89, 0xC4, 0x9A, 0xFB,
+				0x8D, 0xAD,
+				0xED, 0x41,
+				0x99,
+				0x99,
+				0xBB,
+				0x63,
+				0x47,
+				0xD1,
+				0x10,
+				0xF7
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1YCbCr
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC1, 0x3C, 0x50, 0x99,
+				0xC7, 0x66,
+				0xC9, 0x45,
+				0xA8,
+				0x75,
+				0x8A,
+				0xD8,
+				0xA7,
+				0x91,
+				0x44,
+				0x01
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Contrast
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x8A, 0xA7, 0x48, 0xB6,
+				0xD5, 0x0E,
+				0x80, 0x4F,
+				0xA9,
+				0x4A,
+				0x8E,
+				0x82,
+				0x5A,
+				0xCA,
+				0x6B,
+				0x77
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1RgbToHue
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xEC, 0xE5, 0xF3, 0x23,
+				0xE8, 0x91,
+				0x3D, 0x4D,
+				0xAD,
+				0x0A,
+				0xAF,
+				0xAD,
+				0xC1,
+				0x00,
+				0x4A,
+				0xA1
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1HueToRgb
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBD, 0xA6, 0x78, 0x7B,
+				0x41, 0x01,
+				0xEF, 0x4D,
+				0x8A,
+				0x52,
+				0x63,
+				0x56,
+				0xEE,
+				0x0C,
+				0xBD,
+				0xD5
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1ChromaKey
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x5B, 0x1F, 0xC0, 0x74,
+				0x0D, 0x2A,
+				0x8C, 0x40,
+				0x88,
+				0xE2,
+				0xC7,
+				0xA3,
+				0xC7,
+				0x19,
+				0x77,
+				0x42
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Emboss
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x2B, 0xEB, 0xC5, 0xB1,
+				0x48, 0x03,
+				0xF0, 0x43,
+				0x81,
+				0x07,
+				0x49,
+				0x57,
+				0xCA,
+				0xCB,
+				0xA2,
+				0xAE
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Exposure
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xFA, 0x8C, 0x6C, 0xB5,
+				0x34, 0xF6,
+				0xEE, 0x41,
+				0xBE,
+				0xE0,
+				0xFF,
+				0xA6,
+				0x17,
+				0x10,
+				0x60,
+				0x04
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Grayscale
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xEB, 0xE0, 0xDD, 0x36,
+				0x25, 0x37,
+				0xE0, 0x42,
+				0x83,
+				0x6D,
+				0x52,
+				0xFB,
+				0x20,
+				0xAE,
+				0xE6,
+				0x44
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Invert
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4D, 0x78, 0xC3, 0xE0,
+				0x39, 0xCB,
+				0x84, 0x4E,
+				0xB6,
+				0xFD,
+				0x6B,
+				0x72,
+				0xF0,
+				0x81,
+				0x02,
+				0x63
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Posterize
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x5E, 0x94, 0x88, 0x21,
+				0xA3, 0x33,
+				0x66, 0x43,
+				0xB7,
+				0xBC,
+				0x08,
+				0x6B,
+				0xD0,
+				0x2D,
+				0x08,
+				0x84
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Sepia
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x10, 0xF4, 0x1A, 0x3A,
+				0x1D, 0x5F,
+				0xBE, 0x4D,
+				0x84,
+				0xDF,
+				0x91,
+				0x5D,
+				0xA7,
+				0x9B,
+				0x71,
+				0x53
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Sharpen
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xCB, 0x87, 0xB8, 0xC9,
+				0xFF, 0xC5,
+				0xC5, 0x4D,
+				0x97,
+				0x79,
+				0x27,
+				0x3D,
+				0xCF,
+				0x41,
+				0x7C,
+				0x7D
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Straighten
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x12, 0x7B, 0xA4, 0x4D,
+				0xA3, 0x79,
+				0xB0, 0x4F,
+				0x82,
+				0x37,
+				0xBB,
+				0xC3,
+				0xB2,
+				0xA4,
+				0xDE,
+				0x08
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1TemperatureTint
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x87, 0x60, 0x17, 0x89,
+				0xF9, 0x8A,
+				0x08, 0x4A,
+				0xAE,
+				0xB1,
+				0x89,
+				0x5F,
+				0x38,
+				0xDB,
+				0x17,
+				0x66
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Vignette
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBE, 0x40, 0x0C, 0xC0,
+				0x67, 0x5E,
+				0xA3, 0x4C,
+				0x95,
+				0xB4,
+				0xF4,
+				0xB0,
+				0x2C,
+				0x11,
+				0x51,
+				0x35
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1EdgeDetection
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xCA, 0x83, 0xF5, 0xEF,
+				0x07, 0xCB,
+				0xA9, 0x4A,
+				0xAC,
+				0x5D,
+				0x2C,
+				0xC4,
+				0x4C,
+				0x76,
+				0x46,
+				0x0F
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1HighlightsShadows
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x84, 0x83, 0xDC, 0xCA,
+				0x3F, 0x32,
+				0x7E, 0x4C,
+				0xA3,
+				0x61,
+				0x2E,
+				0x2B,
+				0x24,
+				0xDF,
+				0x6E,
+				0xE4
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1LookupTable3D
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xDA, 0x0E, 0x9E, 0x34,
+				0x88, 0x00,
+				0x79, 0x4A,
+				0x9C,
+				0xA3,
+				0xC7,
+				0xE3,
+				0x00,
+				0x20,
+				0x20,
+				0x20
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Opacity
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA4, 0x79, 0x1D, 0x81,
+				0x28, 0xDE,
+				0x54, 0x44,
+				0x80,
+				0x94,
+				0xC6,
+				0x46,
+				0x85,
+				0xF8,
+				0xBD,
+				0x4C
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1AlphaMask
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xF0, 0xCF, 0x0E, 0xC8,
+				0xD5, 0x3F,
+				0x05, 0x4F,
+				0x83,
+				0x28,
+				0xC5,
+				0xD1,
+				0x72,
+				0x4B,
+				0x4F,
+				0x0A
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1CrossFade
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE8, 0x75, 0xF5, 0x12,
+				0xB1, 0x4D,
+				0x5F, 0x48,
+				0x9A,
+				0x84,
+				0x03,
+				0xA0,
+				0x7D,
+				0xD3,
+				0x82,
+				0x9F
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1Tint
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x17, 0x2B, 0x31, 0x36,
+				0xDD, 0xF7,
+				0x14, 0x40,
+				0x91,
+				0x5D,
+				0xFF,
+				0xCA,
+				0x76,
+				0x8C,
+				0xF2,
+				0x11
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public const float D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL = 80f;
+	public static ref readonly Guid CLSID_D2D1WhiteLevelAdjustment
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xDB, 0xCA, 0xA1, 0x44,
+				0xDD, 0x6C,
+				0x18, 0x48,
+				0x8F,
+				0xF4,
+				0x26,
+				0xC1,
+				0xCF,
+				0xE9,
+				0x5B,
+				0xDB
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_D2D1HdrToneMap
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x8D, 0x74, 0x0B, 0x7B,
+				0x10, 0x46,
+				0x86, 0x44,
+				0xA9,
+				0x0C,
+				0x99,
+				0x9D,
+				0x9A,
+				0x2E,
+				0x2B,
+				0x11
+			};
+
+			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public const uint D2D1_APPEND_ALIGNED_ELEMENT = 4294967295;
+	public const uint FACILITY_D2D = 2201;
+}
+
+#region Enums
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION"]/*' />
+/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION</unmanaged>
+public enum InterpolationModeDefinition : int
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_FANT"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_FANT</unmanaged>
+	Fant = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE_DEFINITION::D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR</unmanaged>
+	MipmapLinear = 7,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA"]/*' />
+/// <unmanaged>D2D1_GAMMA</unmanaged>
+public enum Gamma : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA::D2D1_GAMMA_2_2"]/*' />
+	/// <unmanaged>D2D1_GAMMA_2_2</unmanaged>
+	_22 = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA::D2D1_GAMMA_1_0"]/*' />
+	/// <unmanaged>D2D1_GAMMA_1_0</unmanaged>
+	_10 = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITY_MASK_CONTENT"]/*' />
+/// <unmanaged>D2D1_OPACITY_MASK_CONTENT</unmanaged>
+public enum OpacityMaskContent : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITY_MASK_CONTENT::D2D1_OPACITY_MASK_CONTENT_GRAPHICS"]/*' />
+	/// <unmanaged>D2D1_OPACITY_MASK_CONTENT_GRAPHICS</unmanaged>
+	Graphics = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITY_MASK_CONTENT::D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL"]/*' />
+	/// <unmanaged>D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL</unmanaged>
+	TextNatural = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITY_MASK_CONTENT::D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE"]/*' />
+	/// <unmanaged>D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE</unmanaged>
+	TextGDICompatible = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EXTEND_MODE"]/*' />
+/// <unmanaged>D2D1_EXTEND_MODE</unmanaged>
+public enum ExtendMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EXTEND_MODE::D2D1_EXTEND_MODE_CLAMP"]/*' />
+	/// <unmanaged>D2D1_EXTEND_MODE_CLAMP</unmanaged>
+	Clamp = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EXTEND_MODE::D2D1_EXTEND_MODE_WRAP"]/*' />
+	/// <unmanaged>D2D1_EXTEND_MODE_WRAP</unmanaged>
+	Wrap = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EXTEND_MODE::D2D1_EXTEND_MODE_MIRROR"]/*' />
+	/// <unmanaged>D2D1_EXTEND_MODE_MIRROR</unmanaged>
+	Mirror = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ANTIALIAS_MODE"]/*' />
+/// <unmanaged>D2D1_ANTIALIAS_MODE</unmanaged>
+public enum AntialiasMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ANTIALIAS_MODE::D2D1_ANTIALIAS_MODE_PER_PRIMITIVE"]/*' />
+	/// <unmanaged>D2D1_ANTIALIAS_MODE_PER_PRIMITIVE</unmanaged>
+	PerPrimitive = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ANTIALIAS_MODE::D2D1_ANTIALIAS_MODE_ALIASED"]/*' />
+	/// <unmanaged>D2D1_ANTIALIAS_MODE_ALIASED</unmanaged>
+	Aliased = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEXT_ANTIALIAS_MODE"]/*' />
+/// <unmanaged>D2D1_TEXT_ANTIALIAS_MODE</unmanaged>
+public enum TextAntialiasMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEXT_ANTIALIAS_MODE::D2D1_TEXT_ANTIALIAS_MODE_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_TEXT_ANTIALIAS_MODE_DEFAULT</unmanaged>
+	Default = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEXT_ANTIALIAS_MODE::D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE"]/*' />
+	/// <unmanaged>D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE</unmanaged>
+	Cleartype = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEXT_ANTIALIAS_MODE::D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE"]/*' />
+	/// <unmanaged>D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE</unmanaged>
+	Grayscale = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEXT_ANTIALIAS_MODE::D2D1_TEXT_ANTIALIAS_MODE_ALIASED"]/*' />
+	/// <unmanaged>D2D1_TEXT_ANTIALIAS_MODE_ALIASED</unmanaged>
+	Aliased = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_BITMAP_INTERPOLATION_MODE</unmanaged>
+public enum BitmapInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_INTERPOLATION_MODE::D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_INTERPOLATION_MODE::D2D1_BITMAP_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_BITMAP_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAW_TEXT_OPTIONS"]/*' />
+/// <unmanaged>D2D1_DRAW_TEXT_OPTIONS</unmanaged>
+[Flags]
+public enum DrawTextOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAW_TEXT_OPTIONS::D2D1_DRAW_TEXT_OPTIONS_NO_SNAP"]/*' />
+	/// <unmanaged>D2D1_DRAW_TEXT_OPTIONS_NO_SNAP</unmanaged>
+	NoSnap = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAW_TEXT_OPTIONS::D2D1_DRAW_TEXT_OPTIONS_CLIP"]/*' />
+	/// <unmanaged>D2D1_DRAW_TEXT_OPTIONS_CLIP</unmanaged>
+	Clip = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAW_TEXT_OPTIONS::D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT"]/*' />
+	/// <unmanaged>D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT</unmanaged>
+	EnableColorFont = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAW_TEXT_OPTIONS::D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING"]/*' />
+	/// <unmanaged>D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING</unmanaged>
+	DisableColorBitmapSnapping = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAW_TEXT_OPTIONS::D2D1_DRAW_TEXT_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_DRAW_TEXT_OPTIONS_NONE</unmanaged>
+	None = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SIZE"]/*' />
+/// <unmanaged>D2D1_ARC_SIZE</unmanaged>
+public enum ArcSize : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SIZE::D2D1_ARC_SIZE_SMALL"]/*' />
+	/// <unmanaged>D2D1_ARC_SIZE_SMALL</unmanaged>
+	Small = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SIZE::D2D1_ARC_SIZE_LARGE"]/*' />
+	/// <unmanaged>D2D1_ARC_SIZE_LARGE</unmanaged>
+	Large = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CAP_STYLE"]/*' />
+/// <unmanaged>D2D1_CAP_STYLE</unmanaged>
+public enum CapStyle : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CAP_STYLE::D2D1_CAP_STYLE_FLAT"]/*' />
+	/// <unmanaged>D2D1_CAP_STYLE_FLAT</unmanaged>
+	Flat = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CAP_STYLE::D2D1_CAP_STYLE_SQUARE"]/*' />
+	/// <unmanaged>D2D1_CAP_STYLE_SQUARE</unmanaged>
+	Square = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CAP_STYLE::D2D1_CAP_STYLE_ROUND"]/*' />
+	/// <unmanaged>D2D1_CAP_STYLE_ROUND</unmanaged>
+	Round = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CAP_STYLE::D2D1_CAP_STYLE_TRIANGLE"]/*' />
+	/// <unmanaged>D2D1_CAP_STYLE_TRIANGLE</unmanaged>
+	Triangle = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE"]/*' />
+/// <unmanaged>D2D1_DASH_STYLE</unmanaged>
+public enum DashStyle : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE::D2D1_DASH_STYLE_SOLID"]/*' />
+	/// <unmanaged>D2D1_DASH_STYLE_SOLID</unmanaged>
+	Solid = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE::D2D1_DASH_STYLE_DASH"]/*' />
+	/// <unmanaged>D2D1_DASH_STYLE_DASH</unmanaged>
+	Dash = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE::D2D1_DASH_STYLE_DOT"]/*' />
+	/// <unmanaged>D2D1_DASH_STYLE_DOT</unmanaged>
+	Dot = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE::D2D1_DASH_STYLE_DASH_DOT"]/*' />
+	/// <unmanaged>D2D1_DASH_STYLE_DASH_DOT</unmanaged>
+	DashDot = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE::D2D1_DASH_STYLE_DASH_DOT_DOT"]/*' />
+	/// <unmanaged>D2D1_DASH_STYLE_DASH_DOT_DOT</unmanaged>
+	DashDotDot = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DASH_STYLE::D2D1_DASH_STYLE_CUSTOM"]/*' />
+	/// <unmanaged>D2D1_DASH_STYLE_CUSTOM</unmanaged>
+	Custom = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINE_JOIN"]/*' />
+/// <unmanaged>D2D1_LINE_JOIN</unmanaged>
+public enum LineJoin : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINE_JOIN::D2D1_LINE_JOIN_MITER"]/*' />
+	/// <unmanaged>D2D1_LINE_JOIN_MITER</unmanaged>
+	Miter = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINE_JOIN::D2D1_LINE_JOIN_BEVEL"]/*' />
+	/// <unmanaged>D2D1_LINE_JOIN_BEVEL</unmanaged>
+	Bevel = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINE_JOIN::D2D1_LINE_JOIN_ROUND"]/*' />
+	/// <unmanaged>D2D1_LINE_JOIN_ROUND</unmanaged>
+	Round = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINE_JOIN::D2D1_LINE_JOIN_MITER_OR_BEVEL"]/*' />
+	/// <unmanaged>D2D1_LINE_JOIN_MITER_OR_BEVEL</unmanaged>
+	MiterOrBevel = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMBINE_MODE"]/*' />
+/// <unmanaged>D2D1_COMBINE_MODE</unmanaged>
+public enum CombineMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMBINE_MODE::D2D1_COMBINE_MODE_UNION"]/*' />
+	/// <unmanaged>D2D1_COMBINE_MODE_UNION</unmanaged>
+	Union = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMBINE_MODE::D2D1_COMBINE_MODE_INTERSECT"]/*' />
+	/// <unmanaged>D2D1_COMBINE_MODE_INTERSECT</unmanaged>
+	Intersect = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMBINE_MODE::D2D1_COMBINE_MODE_XOR"]/*' />
+	/// <unmanaged>D2D1_COMBINE_MODE_XOR</unmanaged>
+	Xor = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMBINE_MODE::D2D1_COMBINE_MODE_EXCLUDE"]/*' />
+	/// <unmanaged>D2D1_COMBINE_MODE_EXCLUDE</unmanaged>
+	Exclude = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_RELATION"]/*' />
+/// <unmanaged>D2D1_GEOMETRY_RELATION</unmanaged>
+public enum GeometryRelation : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_RELATION::D2D1_GEOMETRY_RELATION_UNKNOWN"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_RELATION_UNKNOWN</unmanaged>
+	Unknown = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_RELATION::D2D1_GEOMETRY_RELATION_DISJOINT"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_RELATION_DISJOINT</unmanaged>
+	Disjoint = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_RELATION::D2D1_GEOMETRY_RELATION_IS_CONTAINED"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_RELATION_IS_CONTAINED</unmanaged>
+	IsContained = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_RELATION::D2D1_GEOMETRY_RELATION_CONTAINS"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_RELATION_CONTAINS</unmanaged>
+	Contains = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_RELATION::D2D1_GEOMETRY_RELATION_OVERLAP"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_RELATION_OVERLAP</unmanaged>
+	Overlap = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_SIMPLIFICATION_OPTION"]/*' />
+/// <unmanaged>D2D1_GEOMETRY_SIMPLIFICATION_OPTION</unmanaged>
+public enum GeometrySimplificationOption : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_SIMPLIFICATION_OPTION::D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES</unmanaged>
+	CubicsAndLines = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GEOMETRY_SIMPLIFICATION_OPTION::D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES"]/*' />
+	/// <unmanaged>D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES</unmanaged>
+	Lines = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SWEEP_DIRECTION"]/*' />
+/// <unmanaged>D2D1_SWEEP_DIRECTION</unmanaged>
+public enum SweepDirection : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SWEEP_DIRECTION::D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE"]/*' />
+	/// <unmanaged>D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE</unmanaged>
+	CounterClockwise = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SWEEP_DIRECTION::D2D1_SWEEP_DIRECTION_CLOCKWISE"]/*' />
+	/// <unmanaged>D2D1_SWEEP_DIRECTION_CLOCKWISE</unmanaged>
+	Clockwise = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS"]/*' />
+/// <unmanaged>D2D1_LAYER_OPTIONS</unmanaged>
+[Flags]
+public enum LayerOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS::D2D1_LAYER_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_LAYER_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS::D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE"]/*' />
+	/// <unmanaged>D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE</unmanaged>
+	InitializeForCleartype = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_WINDOW_STATE"]/*' />
+/// <unmanaged>D2D1_WINDOW_STATE</unmanaged>
+[Flags]
+public enum WindowState : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_WINDOW_STATE::D2D1_WINDOW_STATE_NONE"]/*' />
+	/// <unmanaged>D2D1_WINDOW_STATE_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_WINDOW_STATE::D2D1_WINDOW_STATE_OCCLUDED"]/*' />
+	/// <unmanaged>D2D1_WINDOW_STATE_OCCLUDED</unmanaged>
+	Occluded = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_TYPE"]/*' />
+/// <unmanaged>D2D1_RENDER_TARGET_TYPE</unmanaged>
+public enum RenderTargetType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_TYPE::D2D1_RENDER_TARGET_TYPE_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_RENDER_TARGET_TYPE_DEFAULT</unmanaged>
+	Default = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_TYPE::D2D1_RENDER_TARGET_TYPE_SOFTWARE"]/*' />
+	/// <unmanaged>D2D1_RENDER_TARGET_TYPE_SOFTWARE</unmanaged>
+	Software = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_TYPE::D2D1_RENDER_TARGET_TYPE_HARDWARE"]/*' />
+	/// <unmanaged>D2D1_RENDER_TARGET_TYPE_HARDWARE</unmanaged>
+	Hardware = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_LEVEL"]/*' />
+/// <unmanaged>D2D1_FEATURE_LEVEL</unmanaged>
+public enum FeatureLevel : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_LEVEL::D2D1_FEATURE_LEVEL_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_FEATURE_LEVEL_DEFAULT</unmanaged>
+	Default = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_LEVEL::D2D1_FEATURE_LEVEL_9"]/*' />
+	/// <unmanaged>D2D1_FEATURE_LEVEL_9</unmanaged>
+	Level_9 = 37120,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_LEVEL::D2D1_FEATURE_LEVEL_10"]/*' />
+	/// <unmanaged>D2D1_FEATURE_LEVEL_10</unmanaged>
+	Level_10 = 40960,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_USAGE"]/*' />
+/// <unmanaged>D2D1_RENDER_TARGET_USAGE</unmanaged>
+[Flags]
+public enum RenderTargetUsage : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_USAGE::D2D1_RENDER_TARGET_USAGE_NONE"]/*' />
+	/// <unmanaged>D2D1_RENDER_TARGET_USAGE_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_USAGE::D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING"]/*' />
+	/// <unmanaged>D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING</unmanaged>
+	ForceBitmapRemoting = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_USAGE::D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE"]/*' />
+	/// <unmanaged>D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE</unmanaged>
+	GDICompatible = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRESENT_OPTIONS"]/*' />
+/// <unmanaged>D2D1_PRESENT_OPTIONS</unmanaged>
+[Flags]
+public enum PresentOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRESENT_OPTIONS::D2D1_PRESENT_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_PRESENT_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRESENT_OPTIONS::D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS"]/*' />
+	/// <unmanaged>D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS</unmanaged>
+	RetainContents = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRESENT_OPTIONS::D2D1_PRESENT_OPTIONS_IMMEDIATELY"]/*' />
+	/// <unmanaged>D2D1_PRESENT_OPTIONS_IMMEDIATELY</unmanaged>
+	Immediately = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS"]/*' />
+/// <unmanaged>D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS</unmanaged>
+[Flags]
+public enum CompatibleRenderTargetOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS::D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS::D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE"]/*' />
+	/// <unmanaged>D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE</unmanaged>
+	GDICompatible = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DC_INITIALIZE_MODE"]/*' />
+/// <unmanaged>D2D1_DC_INITIALIZE_MODE</unmanaged>
+public enum DcInitializeMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DC_INITIALIZE_MODE::D2D1_DC_INITIALIZE_MODE_COPY"]/*' />
+	/// <unmanaged>D2D1_DC_INITIALIZE_MODE_COPY</unmanaged>
+	Copy = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DC_INITIALIZE_MODE::D2D1_DC_INITIALIZE_MODE_CLEAR"]/*' />
+	/// <unmanaged>D2D1_DC_INITIALIZE_MODE_CLEAR</unmanaged>
+	Clear = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEBUG_LEVEL"]/*' />
+/// <unmanaged>D2D1_DEBUG_LEVEL</unmanaged>
+public enum DebugLevel : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEBUG_LEVEL::D2D1_DEBUG_LEVEL_NONE"]/*' />
+	/// <unmanaged>D2D1_DEBUG_LEVEL_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEBUG_LEVEL::D2D1_DEBUG_LEVEL_ERROR"]/*' />
+	/// <unmanaged>D2D1_DEBUG_LEVEL_ERROR</unmanaged>
+	Error = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEBUG_LEVEL::D2D1_DEBUG_LEVEL_WARNING"]/*' />
+	/// <unmanaged>D2D1_DEBUG_LEVEL_WARNING</unmanaged>
+	Warning = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEBUG_LEVEL::D2D1_DEBUG_LEVEL_INFORMATION"]/*' />
+	/// <unmanaged>D2D1_DEBUG_LEVEL_INFORMATION</unmanaged>
+	Information = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FACTORY_TYPE"]/*' />
+/// <unmanaged>D2D1_FACTORY_TYPE</unmanaged>
+public enum FactoryType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FACTORY_TYPE::D2D1_FACTORY_TYPE_SINGLE_THREADED"]/*' />
+	/// <unmanaged>D2D1_FACTORY_TYPE_SINGLE_THREADED</unmanaged>
+	SingleThreaded = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FACTORY_TYPE::D2D1_FACTORY_TYPE_MULTI_THREADED"]/*' />
+	/// <unmanaged>D2D1_FACTORY_TYPE_MULTI_THREADED</unmanaged>
+	MultiThreaded = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_SELECTOR"]/*' />
+/// <unmanaged>D2D1_CHANNEL_SELECTOR</unmanaged>
+public enum ChannelSelector : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_SELECTOR::D2D1_CHANNEL_SELECTOR_R"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_SELECTOR_R</unmanaged>
+	R = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_SELECTOR::D2D1_CHANNEL_SELECTOR_G"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_SELECTOR_G</unmanaged>
+	G = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_SELECTOR::D2D1_CHANNEL_SELECTOR_B"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_SELECTOR_B</unmanaged>
+	B = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_SELECTOR::D2D1_CHANNEL_SELECTOR_A"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_SELECTOR_A</unmanaged>
+	A = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION"]/*' />
+/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION</unmanaged>
+public enum BitmapsourceOrientation : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_DEFAULT</unmanaged>
+	Default = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_FLIP_HORIZONTAL</unmanaged>
+	FlipHorizontal = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180</unmanaged>
+	RotateClockwise180 = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL</unmanaged>
+	RotateClockwise180FlipHorizontal = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL</unmanaged>
+	RotateClockwise270FlipHorizontal = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90</unmanaged>
+	RotateClockwise90 = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL</unmanaged>
+	RotateClockwise90FlipHorizontal = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ORIENTATION::D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270</unmanaged>
+	RotateClockwise270 = 8,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_PROP"]/*' />
+/// <unmanaged>D2D1_GAUSSIANBLUR_PROP</unmanaged>
+public enum GaussianblurProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_PROP::D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION"]/*' />
+	/// <unmanaged>D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION</unmanaged>
+	StandardDeviation = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_PROP::D2D1_GAUSSIANBLUR_PROP_OPTIMIZATION"]/*' />
+	/// <unmanaged>D2D1_GAUSSIANBLUR_PROP_OPTIMIZATION</unmanaged>
+	Optimization = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_PROP::D2D1_GAUSSIANBLUR_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_GAUSSIANBLUR_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_OPTIMIZATION"]/*' />
+/// <unmanaged>D2D1_GAUSSIANBLUR_OPTIMIZATION</unmanaged>
+public enum GaussianblurOptimization : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_OPTIMIZATION::D2D1_GAUSSIANBLUR_OPTIMIZATION_SPEED"]/*' />
+	/// <unmanaged>D2D1_GAUSSIANBLUR_OPTIMIZATION_SPEED</unmanaged>
+	Speed = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_OPTIMIZATION::D2D1_GAUSSIANBLUR_OPTIMIZATION_BALANCED"]/*' />
+	/// <unmanaged>D2D1_GAUSSIANBLUR_OPTIMIZATION_BALANCED</unmanaged>
+	Balanced = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAUSSIANBLUR_OPTIMIZATION::D2D1_GAUSSIANBLUR_OPTIMIZATION_QUALITY"]/*' />
+	/// <unmanaged>D2D1_GAUSSIANBLUR_OPTIMIZATION_QUALITY</unmanaged>
+	Quality = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_PROP"]/*' />
+/// <unmanaged>D2D1_DIRECTIONALBLUR_PROP</unmanaged>
+public enum DirectionalblurProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_PROP::D2D1_DIRECTIONALBLUR_PROP_STANDARD_DEVIATION"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_PROP_STANDARD_DEVIATION</unmanaged>
+	StandardDeviation = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_PROP::D2D1_DIRECTIONALBLUR_PROP_ANGLE"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_PROP_ANGLE</unmanaged>
+	Angle = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_PROP::D2D1_DIRECTIONALBLUR_PROP_OPTIMIZATION"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_PROP_OPTIMIZATION</unmanaged>
+	Optimization = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_PROP::D2D1_DIRECTIONALBLUR_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_OPTIMIZATION"]/*' />
+/// <unmanaged>D2D1_DIRECTIONALBLUR_OPTIMIZATION</unmanaged>
+public enum DirectionalblurOptimization : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_OPTIMIZATION::D2D1_DIRECTIONALBLUR_OPTIMIZATION_SPEED"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_OPTIMIZATION_SPEED</unmanaged>
+	Speed = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_OPTIMIZATION::D2D1_DIRECTIONALBLUR_OPTIMIZATION_BALANCED"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_OPTIMIZATION_BALANCED</unmanaged>
+	Balanced = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DIRECTIONALBLUR_OPTIMIZATION::D2D1_DIRECTIONALBLUR_OPTIMIZATION_QUALITY"]/*' />
+	/// <unmanaged>D2D1_DIRECTIONALBLUR_OPTIMIZATION_QUALITY</unmanaged>
+	Quality = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_PROP"]/*' />
+/// <unmanaged>D2D1_SHADOW_PROP</unmanaged>
+public enum ShadowProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_PROP::D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION"]/*' />
+	/// <unmanaged>D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION</unmanaged>
+	BlurStandardDeviation = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_PROP::D2D1_SHADOW_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_SHADOW_PROP_COLOR</unmanaged>
+	Color = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_PROP::D2D1_SHADOW_PROP_OPTIMIZATION"]/*' />
+	/// <unmanaged>D2D1_SHADOW_PROP_OPTIMIZATION</unmanaged>
+	Optimization = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_OPTIMIZATION"]/*' />
+/// <unmanaged>D2D1_SHADOW_OPTIMIZATION</unmanaged>
+public enum ShadowOptimization : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_OPTIMIZATION::D2D1_SHADOW_OPTIMIZATION_SPEED"]/*' />
+	/// <unmanaged>D2D1_SHADOW_OPTIMIZATION_SPEED</unmanaged>
+	Speed = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_OPTIMIZATION::D2D1_SHADOW_OPTIMIZATION_BALANCED"]/*' />
+	/// <unmanaged>D2D1_SHADOW_OPTIMIZATION_BALANCED</unmanaged>
+	Balanced = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHADOW_OPTIMIZATION::D2D1_SHADOW_OPTIMIZATION_QUALITY"]/*' />
+	/// <unmanaged>D2D1_SHADOW_OPTIMIZATION_QUALITY</unmanaged>
+	Quality = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_PROP"]/*' />
+/// <unmanaged>D2D1_BLEND_PROP</unmanaged>
+public enum BlendProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_PROP::D2D1_BLEND_PROP_MODE"]/*' />
+	/// <unmanaged>D2D1_BLEND_PROP_MODE</unmanaged>
+	Mode = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SATURATION_PROP"]/*' />
+/// <unmanaged>D2D1_SATURATION_PROP</unmanaged>
+public enum SaturationProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SATURATION_PROP::D2D1_SATURATION_PROP_SATURATION"]/*' />
+	/// <unmanaged>D2D1_SATURATION_PROP_SATURATION</unmanaged>
+	Saturation = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUEROTATION_PROP"]/*' />
+/// <unmanaged>D2D1_HUEROTATION_PROP</unmanaged>
+public enum HuerotationProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUEROTATION_PROP::D2D1_HUEROTATION_PROP_ANGLE"]/*' />
+	/// <unmanaged>D2D1_HUEROTATION_PROP_ANGLE</unmanaged>
+	Angle = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMATRIX_PROP"]/*' />
+/// <unmanaged>D2D1_COLORMATRIX_PROP</unmanaged>
+public enum ColorMatrixProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMATRIX_PROP::D2D1_COLORMATRIX_PROP_COLOR_MATRIX"]/*' />
+	/// <unmanaged>D2D1_COLORMATRIX_PROP_COLOR_MATRIX</unmanaged>
+	ColorMatrix = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMATRIX_PROP::D2D1_COLORMATRIX_PROP_ALPHA_MODE"]/*' />
+	/// <unmanaged>D2D1_COLORMATRIX_PROP_ALPHA_MODE</unmanaged>
+	AlphaMode = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMATRIX_PROP::D2D1_COLORMATRIX_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_COLORMATRIX_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP"]/*' />
+/// <unmanaged>D2D1_BITMAPSOURCE_PROP</unmanaged>
+public enum BitmapsourceProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP::D2D1_BITMAPSOURCE_PROP_WIC_BITMAP_SOURCE"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_PROP_WIC_BITMAP_SOURCE</unmanaged>
+	WicBitmapSource = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP::D2D1_BITMAPSOURCE_PROP_SCALE"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_PROP_SCALE</unmanaged>
+	Scale = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP::D2D1_BITMAPSOURCE_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP::D2D1_BITMAPSOURCE_PROP_ENABLE_DPI_CORRECTION"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_PROP_ENABLE_DPI_CORRECTION</unmanaged>
+	EnableDpiCorrection = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP::D2D1_BITMAPSOURCE_PROP_ALPHA_MODE"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_PROP_ALPHA_MODE</unmanaged>
+	AlphaMode = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_PROP::D2D1_BITMAPSOURCE_PROP_ORIENTATION"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_PROP_ORIENTATION</unmanaged>
+	Orientation = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_BITMAPSOURCE_INTERPOLATION_MODE</unmanaged>
+public enum BitmapsourceInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_INTERPOLATION_MODE::D2D1_BITMAPSOURCE_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_INTERPOLATION_MODE::D2D1_BITMAPSOURCE_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_INTERPOLATION_MODE::D2D1_BITMAPSOURCE_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_INTERPOLATION_MODE::D2D1_BITMAPSOURCE_INTERPOLATION_MODE_FANT"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_INTERPOLATION_MODE_FANT</unmanaged>
+	Fant = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_INTERPOLATION_MODE::D2D1_BITMAPSOURCE_INTERPOLATION_MODE_MIPMAP_LINEAR"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_INTERPOLATION_MODE_MIPMAP_LINEAR</unmanaged>
+	MipmapLinear = 7,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ALPHA_MODE"]/*' />
+/// <unmanaged>D2D1_BITMAPSOURCE_ALPHA_MODE</unmanaged>
+public enum BitmapsourceAlphaMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ALPHA_MODE::D2D1_BITMAPSOURCE_ALPHA_MODE_PREMULTIPLIED"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ALPHA_MODE_PREMULTIPLIED</unmanaged>
+	Premultiplied = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAPSOURCE_ALPHA_MODE::D2D1_BITMAPSOURCE_ALPHA_MODE_STRAIGHT"]/*' />
+	/// <unmanaged>D2D1_BITMAPSOURCE_ALPHA_MODE_STRAIGHT</unmanaged>
+	Straight = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMPOSITE_PROP"]/*' />
+/// <unmanaged>D2D1_COMPOSITE_PROP</unmanaged>
+public enum CompositeProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COMPOSITE_PROP::D2D1_COMPOSITE_PROP_MODE"]/*' />
+	/// <unmanaged>D2D1_COMPOSITE_PROP_MODE</unmanaged>
+	Mode = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_PROP"]/*' />
+/// <unmanaged>D2D1_3DTRANSFORM_PROP</unmanaged>
+public enum _3dtransformProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_PROP::D2D1_3DTRANSFORM_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_PROP::D2D1_3DTRANSFORM_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_PROP::D2D1_3DTRANSFORM_PROP_TRANSFORM_MATRIX"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_PROP_TRANSFORM_MATRIX</unmanaged>
+	TransformMatrix = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_3DTRANSFORM_INTERPOLATION_MODE</unmanaged>
+public enum _3dtransformInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_INTERPOLATION_MODE::D2D1_3DTRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_INTERPOLATION_MODE::D2D1_3DTRANSFORM_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_INTERPOLATION_MODE::D2D1_3DTRANSFORM_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_INTERPOLATION_MODE::D2D1_3DTRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DTRANSFORM_INTERPOLATION_MODE::D2D1_3DTRANSFORM_INTERPOLATION_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_3DTRANSFORM_INTERPOLATION_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP"]/*' />
+/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP</unmanaged>
+public enum _3dperspectivetransformProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_DEPTH"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_DEPTH</unmanaged>
+	Depth = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_PERSPECTIVE_ORIGIN"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_PERSPECTIVE_ORIGIN</unmanaged>
+	PerspectiveOrigin = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_LOCAL_OFFSET"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_LOCAL_OFFSET</unmanaged>
+	LocalOffset = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_GLOBAL_OFFSET"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_GLOBAL_OFFSET</unmanaged>
+	GlobalOffset = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION_ORIGIN"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION_ORIGIN</unmanaged>
+	RotationOrigin = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_PROP::D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION</unmanaged>
+	Rotation = 7,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE</unmanaged>
+public enum _3dperspectivetransformInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE::D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE::D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE::D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE::D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE::D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_2DAFFINETRANSFORM_PROP"]/*' />
+/// <unmanaged>D2D1_2DAFFINETRANSFORM_PROP</unmanaged>
+public enum _2daffinetransformProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_2DAFFINETRANSFORM_PROP::D2D1_2DAFFINETRANSFORM_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_2DAFFINETRANSFORM_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_2DAFFINETRANSFORM_PROP::D2D1_2DAFFINETRANSFORM_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_2DAFFINETRANSFORM_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_2DAFFINETRANSFORM_PROP::D2D1_2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX"]/*' />
+	/// <unmanaged>D2D1_2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX</unmanaged>
+	TransformMatrix = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_2DAFFINETRANSFORM_PROP::D2D1_2DAFFINETRANSFORM_PROP_SHARPNESS"]/*' />
+	/// <unmanaged>D2D1_2DAFFINETRANSFORM_PROP_SHARPNESS</unmanaged>
+	Sharpness = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_PROP"]/*' />
+/// <unmanaged>D2D1_DPICOMPENSATION_PROP</unmanaged>
+public enum DpicompensationProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_PROP::D2D1_DPICOMPENSATION_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_PROP::D2D1_DPICOMPENSATION_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_PROP::D2D1_DPICOMPENSATION_PROP_INPUT_DPI"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_PROP_INPUT_DPI</unmanaged>
+	InputDpi = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE</unmanaged>
+public enum DpicompensationInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE::D2D1_DPICOMPENSATION_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE::D2D1_DPICOMPENSATION_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE::D2D1_DPICOMPENSATION_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE::D2D1_DPICOMPENSATION_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE::D2D1_DPICOMPENSATION_INTERPOLATION_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DPICOMPENSATION_INTERPOLATION_MODE::D2D1_DPICOMPENSATION_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_DPICOMPENSATION_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_PROP"]/*' />
+/// <unmanaged>D2D1_SCALE_PROP</unmanaged>
+public enum ScaleProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_PROP::D2D1_SCALE_PROP_SCALE"]/*' />
+	/// <unmanaged>D2D1_SCALE_PROP_SCALE</unmanaged>
+	Scale = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_PROP::D2D1_SCALE_PROP_CENTER_POINT"]/*' />
+	/// <unmanaged>D2D1_SCALE_PROP_CENTER_POINT</unmanaged>
+	CenterPoint = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_PROP::D2D1_SCALE_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_SCALE_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_PROP::D2D1_SCALE_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_SCALE_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_PROP::D2D1_SCALE_PROP_SHARPNESS"]/*' />
+	/// <unmanaged>D2D1_SCALE_PROP_SHARPNESS</unmanaged>
+	Sharpness = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE</unmanaged>
+public enum ScaleInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE::D2D1_SCALE_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE::D2D1_SCALE_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE::D2D1_SCALE_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE::D2D1_SCALE_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE::D2D1_SCALE_INTERPOLATION_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SCALE_INTERPOLATION_MODE::D2D1_SCALE_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_SCALE_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP"]/*' />
+/// <unmanaged>D2D1_TURBULENCE_PROP</unmanaged>
+public enum TurbulenceProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_OFFSET"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_OFFSET</unmanaged>
+	Offset = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_SIZE"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_SIZE</unmanaged>
+	Size = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_BASE_FREQUENCY"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_BASE_FREQUENCY</unmanaged>
+	BaseFrequency = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_NUM_OCTAVES"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_NUM_OCTAVES</unmanaged>
+	NumOctaves = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_SEED"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_SEED</unmanaged>
+	Seed = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_NOISE"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_NOISE</unmanaged>
+	Noise = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TURBULENCE_PROP::D2D1_TURBULENCE_PROP_STITCHABLE"]/*' />
+	/// <unmanaged>D2D1_TURBULENCE_PROP_STITCHABLE</unmanaged>
+	Stitchable = 6,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISPLACEMENTMAP_PROP"]/*' />
+/// <unmanaged>D2D1_DISPLACEMENTMAP_PROP</unmanaged>
+public enum DisplacementmapProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISPLACEMENTMAP_PROP::D2D1_DISPLACEMENTMAP_PROP_SCALE"]/*' />
+	/// <unmanaged>D2D1_DISPLACEMENTMAP_PROP_SCALE</unmanaged>
+	Scale = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISPLACEMENTMAP_PROP::D2D1_DISPLACEMENTMAP_PROP_X_CHANNEL_SELECT"]/*' />
+	/// <unmanaged>D2D1_DISPLACEMENTMAP_PROP_X_CHANNEL_SELECT</unmanaged>
+	XChannelSelect = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISPLACEMENTMAP_PROP::D2D1_DISPLACEMENTMAP_PROP_Y_CHANNEL_SELECT"]/*' />
+	/// <unmanaged>D2D1_DISPLACEMENTMAP_PROP_Y_CHANNEL_SELECT</unmanaged>
+	YChannelSelect = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP"]/*' />
+/// <unmanaged>D2D1_COLORMANAGEMENT_PROP</unmanaged>
+public enum ColormanagementProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP::D2D1_COLORMANAGEMENT_PROP_SOURCE_COLOR_CONTEXT"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_PROP_SOURCE_COLOR_CONTEXT</unmanaged>
+	SourceColorContext = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP::D2D1_COLORMANAGEMENT_PROP_SOURCE_RENDERING_INTENT"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_PROP_SOURCE_RENDERING_INTENT</unmanaged>
+	SourceRenderingIntent = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP::D2D1_COLORMANAGEMENT_PROP_DESTINATION_COLOR_CONTEXT"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_PROP_DESTINATION_COLOR_CONTEXT</unmanaged>
+	DestinationColorContext = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP::D2D1_COLORMANAGEMENT_PROP_DESTINATION_RENDERING_INTENT"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_PROP_DESTINATION_RENDERING_INTENT</unmanaged>
+	DestinationRenderingIntent = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP::D2D1_COLORMANAGEMENT_PROP_ALPHA_MODE"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_PROP_ALPHA_MODE</unmanaged>
+	AlphaMode = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_PROP::D2D1_COLORMANAGEMENT_PROP_QUALITY"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_PROP_QUALITY</unmanaged>
+	Quality = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_ALPHA_MODE"]/*' />
+/// <unmanaged>D2D1_COLORMANAGEMENT_ALPHA_MODE</unmanaged>
+public enum ColormanagementAlphaMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_ALPHA_MODE::D2D1_COLORMANAGEMENT_ALPHA_MODE_PREMULTIPLIED"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_ALPHA_MODE_PREMULTIPLIED</unmanaged>
+	Premultiplied = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_ALPHA_MODE::D2D1_COLORMANAGEMENT_ALPHA_MODE_STRAIGHT"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_ALPHA_MODE_STRAIGHT</unmanaged>
+	Straight = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_QUALITY"]/*' />
+/// <unmanaged>D2D1_COLORMANAGEMENT_QUALITY</unmanaged>
+public enum ColormanagementQuality : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_QUALITY::D2D1_COLORMANAGEMENT_QUALITY_PROOF"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_QUALITY_PROOF</unmanaged>
+	Proof = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_QUALITY::D2D1_COLORMANAGEMENT_QUALITY_NORMAL"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_QUALITY_NORMAL</unmanaged>
+	Normal = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_QUALITY::D2D1_COLORMANAGEMENT_QUALITY_BEST"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_QUALITY_BEST</unmanaged>
+	Best = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_RENDERING_INTENT"]/*' />
+/// <unmanaged>D2D1_COLORMANAGEMENT_RENDERING_INTENT</unmanaged>
+public enum ColormanagementRenderingIntent : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_RENDERING_INTENT::D2D1_COLORMANAGEMENT_RENDERING_INTENT_PERCEPTUAL"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_RENDERING_INTENT_PERCEPTUAL</unmanaged>
+	Perceptual = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_RENDERING_INTENT::D2D1_COLORMANAGEMENT_RENDERING_INTENT_RELATIVE_COLORIMETRIC"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_RENDERING_INTENT_RELATIVE_COLORIMETRIC</unmanaged>
+	RelativeColorimetric = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_RENDERING_INTENT::D2D1_COLORMANAGEMENT_RENDERING_INTENT_SATURATION"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_RENDERING_INTENT_SATURATION</unmanaged>
+	Saturation = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLORMANAGEMENT_RENDERING_INTENT::D2D1_COLORMANAGEMENT_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC"]/*' />
+	/// <unmanaged>D2D1_COLORMANAGEMENT_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC</unmanaged>
+	AbsoluteColorimetric = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HISTOGRAM_PROP"]/*' />
+/// <unmanaged>D2D1_HISTOGRAM_PROP</unmanaged>
+public enum HistogramProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HISTOGRAM_PROP::D2D1_HISTOGRAM_PROP_NUM_BINS"]/*' />
+	/// <unmanaged>D2D1_HISTOGRAM_PROP_NUM_BINS</unmanaged>
+	NumBins = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HISTOGRAM_PROP::D2D1_HISTOGRAM_PROP_CHANNEL_SELECT"]/*' />
+	/// <unmanaged>D2D1_HISTOGRAM_PROP_CHANNEL_SELECT</unmanaged>
+	ChannelSelect = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HISTOGRAM_PROP::D2D1_HISTOGRAM_PROP_HISTOGRAM_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_HISTOGRAM_PROP_HISTOGRAM_OUTPUT</unmanaged>
+	HistogramOutput = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP"]/*' />
+/// <unmanaged>D2D1_POINTSPECULAR_PROP</unmanaged>
+public enum PointspecularProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_LIGHT_POSITION"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_LIGHT_POSITION</unmanaged>
+	LightPosition = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_SPECULAR_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_SPECULAR_EXPONENT</unmanaged>
+	SpecularExponent = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_SPECULAR_CONSTANT"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_SPECULAR_CONSTANT</unmanaged>
+	SpecularConstant = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_SURFACE_SCALE"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_SURFACE_SCALE</unmanaged>
+	SurfaceScale = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_COLOR</unmanaged>
+	Color = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_PROP::D2D1_POINTSPECULAR_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 6,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE</unmanaged>
+public enum PointspecularScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE::D2D1_POINTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE::D2D1_POINTSPECULAR_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE::D2D1_POINTSPECULAR_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE::D2D1_POINTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE::D2D1_POINTSPECULAR_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTSPECULAR_SCALE_MODE::D2D1_POINTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_POINTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP"]/*' />
+/// <unmanaged>D2D1_SPOTSPECULAR_PROP</unmanaged>
+public enum SpotspecularProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_LIGHT_POSITION"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_LIGHT_POSITION</unmanaged>
+	LightPosition = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_POINTS_AT"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_POINTS_AT</unmanaged>
+	PointsAt = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_FOCUS"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_FOCUS</unmanaged>
+	Focus = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_LIMITING_CONE_ANGLE"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_LIMITING_CONE_ANGLE</unmanaged>
+	LimitingConeAngle = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_SPECULAR_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_SPECULAR_EXPONENT</unmanaged>
+	SpecularExponent = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_SPECULAR_CONSTANT"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_SPECULAR_CONSTANT</unmanaged>
+	SpecularConstant = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_SURFACE_SCALE"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_SURFACE_SCALE</unmanaged>
+	SurfaceScale = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_COLOR</unmanaged>
+	Color = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_PROP::D2D1_SPOTSPECULAR_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 9,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE</unmanaged>
+public enum SpotspecularScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE::D2D1_SPOTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE::D2D1_SPOTSPECULAR_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE::D2D1_SPOTSPECULAR_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE::D2D1_SPOTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE::D2D1_SPOTSPECULAR_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTSPECULAR_SCALE_MODE::D2D1_SPOTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_SPOTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP"]/*' />
+/// <unmanaged>D2D1_DISTANTSPECULAR_PROP</unmanaged>
+public enum DistantspecularProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_AZIMUTH"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_AZIMUTH</unmanaged>
+	Azimuth = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_ELEVATION"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_ELEVATION</unmanaged>
+	Elevation = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_SPECULAR_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_SPECULAR_EXPONENT</unmanaged>
+	SpecularExponent = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_SPECULAR_CONSTANT"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_SPECULAR_CONSTANT</unmanaged>
+	SpecularConstant = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_SURFACE_SCALE"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_SURFACE_SCALE</unmanaged>
+	SurfaceScale = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_COLOR</unmanaged>
+	Color = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_PROP::D2D1_DISTANTSPECULAR_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 7,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE</unmanaged>
+public enum DistantspecularScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE::D2D1_DISTANTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE::D2D1_DISTANTSPECULAR_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE::D2D1_DISTANTSPECULAR_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE::D2D1_DISTANTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE::D2D1_DISTANTSPECULAR_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTSPECULAR_SCALE_MODE::D2D1_DISTANTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_DISTANTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP"]/*' />
+/// <unmanaged>D2D1_POINTDIFFUSE_PROP</unmanaged>
+public enum PointdiffuseProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP::D2D1_POINTDIFFUSE_PROP_LIGHT_POSITION"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_PROP_LIGHT_POSITION</unmanaged>
+	LightPosition = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP::D2D1_POINTDIFFUSE_PROP_DIFFUSE_CONSTANT"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_PROP_DIFFUSE_CONSTANT</unmanaged>
+	DiffuseConstant = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP::D2D1_POINTDIFFUSE_PROP_SURFACE_SCALE"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_PROP_SURFACE_SCALE</unmanaged>
+	SurfaceScale = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP::D2D1_POINTDIFFUSE_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_PROP_COLOR</unmanaged>
+	Color = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP::D2D1_POINTDIFFUSE_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_PROP::D2D1_POINTDIFFUSE_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE</unmanaged>
+public enum PointdiffuseScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE::D2D1_POINTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE::D2D1_POINTDIFFUSE_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE::D2D1_POINTDIFFUSE_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE::D2D1_POINTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE::D2D1_POINTDIFFUSE_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINTDIFFUSE_SCALE_MODE::D2D1_POINTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_POINTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP"]/*' />
+/// <unmanaged>D2D1_SPOTDIFFUSE_PROP</unmanaged>
+public enum SpotdiffuseProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_LIGHT_POSITION"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_LIGHT_POSITION</unmanaged>
+	LightPosition = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_POINTS_AT"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_POINTS_AT</unmanaged>
+	PointsAt = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_FOCUS"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_FOCUS</unmanaged>
+	Focus = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_LIMITING_CONE_ANGLE"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_LIMITING_CONE_ANGLE</unmanaged>
+	LimitingConeAngle = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_DIFFUSE_CONSTANT"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_DIFFUSE_CONSTANT</unmanaged>
+	DiffuseConstant = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_SURFACE_SCALE"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_SURFACE_SCALE</unmanaged>
+	SurfaceScale = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_COLOR</unmanaged>
+	Color = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_PROP::D2D1_SPOTDIFFUSE_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 8,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE</unmanaged>
+public enum SpotdiffuseScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE::D2D1_SPOTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE::D2D1_SPOTDIFFUSE_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE::D2D1_SPOTDIFFUSE_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE::D2D1_SPOTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE::D2D1_SPOTDIFFUSE_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPOTDIFFUSE_SCALE_MODE::D2D1_SPOTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_SPOTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP"]/*' />
+/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP</unmanaged>
+public enum DistantdiffuseProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_AZIMUTH"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_AZIMUTH</unmanaged>
+	Azimuth = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_ELEVATION"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_ELEVATION</unmanaged>
+	Elevation = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_DIFFUSE_CONSTANT"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_DIFFUSE_CONSTANT</unmanaged>
+	DiffuseConstant = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_SURFACE_SCALE"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_SURFACE_SCALE</unmanaged>
+	SurfaceScale = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_COLOR</unmanaged>
+	Color = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_PROP::D2D1_DISTANTDIFFUSE_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 6,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE</unmanaged>
+public enum DistantdiffuseScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE::D2D1_DISTANTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE::D2D1_DISTANTDIFFUSE_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE::D2D1_DISTANTDIFFUSE_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE::D2D1_DISTANTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE::D2D1_DISTANTDIFFUSE_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISTANTDIFFUSE_SCALE_MODE::D2D1_DISTANTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_DISTANTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FLOOD_PROP"]/*' />
+/// <unmanaged>D2D1_FLOOD_PROP</unmanaged>
+public enum FloodProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FLOOD_PROP::D2D1_FLOOD_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_FLOOD_PROP_COLOR</unmanaged>
+	Color = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP"]/*' />
+/// <unmanaged>D2D1_LINEARTRANSFER_PROP</unmanaged>
+public enum LineartransferProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_RED_Y_INTERCEPT"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_RED_Y_INTERCEPT</unmanaged>
+	RedYIntercept = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_RED_SLOPE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_RED_SLOPE</unmanaged>
+	RedSlope = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_RED_DISABLE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_RED_DISABLE</unmanaged>
+	RedDisable = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_GREEN_Y_INTERCEPT"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_GREEN_Y_INTERCEPT</unmanaged>
+	GreenYIntercept = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_GREEN_SLOPE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_GREEN_SLOPE</unmanaged>
+	GreenSlope = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_GREEN_DISABLE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_GREEN_DISABLE</unmanaged>
+	GreenDisable = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_BLUE_Y_INTERCEPT"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_BLUE_Y_INTERCEPT</unmanaged>
+	BlueYIntercept = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_BLUE_SLOPE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_BLUE_SLOPE</unmanaged>
+	BlueSlope = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_BLUE_DISABLE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_BLUE_DISABLE</unmanaged>
+	BlueDisable = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_ALPHA_Y_INTERCEPT"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_ALPHA_Y_INTERCEPT</unmanaged>
+	AlphaYIntercept = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_ALPHA_SLOPE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_ALPHA_SLOPE</unmanaged>
+	AlphaSlope = 10,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_ALPHA_DISABLE"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_ALPHA_DISABLE</unmanaged>
+	AlphaDisable = 11,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEARTRANSFER_PROP::D2D1_LINEARTRANSFER_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_LINEARTRANSFER_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 12,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP"]/*' />
+/// <unmanaged>D2D1_GAMMATRANSFER_PROP</unmanaged>
+public enum GammatransferProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_RED_AMPLITUDE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_RED_AMPLITUDE</unmanaged>
+	RedAmplitude = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_RED_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_RED_EXPONENT</unmanaged>
+	RedExponent = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_RED_OFFSET"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_RED_OFFSET</unmanaged>
+	RedOffset = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_RED_DISABLE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_RED_DISABLE</unmanaged>
+	RedDisable = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_GREEN_AMPLITUDE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_GREEN_AMPLITUDE</unmanaged>
+	GreenAmplitude = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_GREEN_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_GREEN_EXPONENT</unmanaged>
+	GreenExponent = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_GREEN_OFFSET"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_GREEN_OFFSET</unmanaged>
+	GreenOffset = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_GREEN_DISABLE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_GREEN_DISABLE</unmanaged>
+	GreenDisable = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_BLUE_AMPLITUDE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_BLUE_AMPLITUDE</unmanaged>
+	BlueAmplitude = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_BLUE_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_BLUE_EXPONENT</unmanaged>
+	BlueExponent = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_BLUE_OFFSET"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_BLUE_OFFSET</unmanaged>
+	BlueOffset = 10,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_BLUE_DISABLE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_BLUE_DISABLE</unmanaged>
+	BlueDisable = 11,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_ALPHA_AMPLITUDE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_ALPHA_AMPLITUDE</unmanaged>
+	AlphaAmplitude = 12,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_ALPHA_EXPONENT"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_ALPHA_EXPONENT</unmanaged>
+	AlphaExponent = 13,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_ALPHA_OFFSET"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_ALPHA_OFFSET</unmanaged>
+	AlphaOffset = 14,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_ALPHA_DISABLE"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_ALPHA_DISABLE</unmanaged>
+	AlphaDisable = 15,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMATRANSFER_PROP::D2D1_GAMMATRANSFER_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_GAMMATRANSFER_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 16,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP"]/*' />
+/// <unmanaged>D2D1_TABLETRANSFER_PROP</unmanaged>
+public enum TabletransferProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_RED_TABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_RED_TABLE</unmanaged>
+	RedTable = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_RED_DISABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_RED_DISABLE</unmanaged>
+	RedDisable = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_GREEN_TABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_GREEN_TABLE</unmanaged>
+	GreenTable = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_GREEN_DISABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_GREEN_DISABLE</unmanaged>
+	GreenDisable = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_BLUE_TABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_BLUE_TABLE</unmanaged>
+	BlueTable = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_BLUE_DISABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_BLUE_DISABLE</unmanaged>
+	BlueDisable = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_ALPHA_TABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_ALPHA_TABLE</unmanaged>
+	AlphaTable = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_ALPHA_DISABLE"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_ALPHA_DISABLE</unmanaged>
+	AlphaDisable = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TABLETRANSFER_PROP::D2D1_TABLETRANSFER_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_TABLETRANSFER_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 8,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP"]/*' />
+/// <unmanaged>D2D1_DISCRETETRANSFER_PROP</unmanaged>
+public enum DiscretetransferProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_RED_TABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_RED_TABLE</unmanaged>
+	RedTable = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_RED_DISABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_RED_DISABLE</unmanaged>
+	RedDisable = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_GREEN_TABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_GREEN_TABLE</unmanaged>
+	GreenTable = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_GREEN_DISABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_GREEN_DISABLE</unmanaged>
+	GreenDisable = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_BLUE_TABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_BLUE_TABLE</unmanaged>
+	BlueTable = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_BLUE_DISABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_BLUE_DISABLE</unmanaged>
+	BlueDisable = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_ALPHA_TABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_ALPHA_TABLE</unmanaged>
+	AlphaTable = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_ALPHA_DISABLE"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_ALPHA_DISABLE</unmanaged>
+	AlphaDisable = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DISCRETETRANSFER_PROP::D2D1_DISCRETETRANSFER_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_DISCRETETRANSFER_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 8,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP"]/*' />
+/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP</unmanaged>
+public enum ConvolvematrixProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_KERNEL_UNIT_LENGTH"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_KERNEL_UNIT_LENGTH</unmanaged>
+	KernelUnitLength = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_X"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_X</unmanaged>
+	KernelSizeX = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_Y"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_Y</unmanaged>
+	KernelSizeY = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_KERNEL_MATRIX"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_KERNEL_MATRIX</unmanaged>
+	KernelMatrix = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_DIVISOR"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_DIVISOR</unmanaged>
+	Divisor = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_BIAS"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_BIAS</unmanaged>
+	Bias = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_KERNEL_OFFSET"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_KERNEL_OFFSET</unmanaged>
+	KernelOffset = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_PRESERVE_ALPHA"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_PRESERVE_ALPHA</unmanaged>
+	PreserveAlpha = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_PROP::D2D1_CONVOLVEMATRIX_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 10,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE</unmanaged>
+public enum ConvolvematrixScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE::D2D1_CONVOLVEMATRIX_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE::D2D1_CONVOLVEMATRIX_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE::D2D1_CONVOLVEMATRIX_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE::D2D1_CONVOLVEMATRIX_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE::D2D1_CONVOLVEMATRIX_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONVOLVEMATRIX_SCALE_MODE::D2D1_CONVOLVEMATRIX_SCALE_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_CONVOLVEMATRIX_SCALE_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BRIGHTNESS_PROP"]/*' />
+/// <unmanaged>D2D1_BRIGHTNESS_PROP</unmanaged>
+public enum BrightnessProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BRIGHTNESS_PROP::D2D1_BRIGHTNESS_PROP_WHITE_POINT"]/*' />
+	/// <unmanaged>D2D1_BRIGHTNESS_PROP_WHITE_POINT</unmanaged>
+	WhitePoint = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BRIGHTNESS_PROP::D2D1_BRIGHTNESS_PROP_BLACK_POINT"]/*' />
+	/// <unmanaged>D2D1_BRIGHTNESS_PROP_BLACK_POINT</unmanaged>
+	BlackPoint = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARITHMETICCOMPOSITE_PROP"]/*' />
+/// <unmanaged>D2D1_ARITHMETICCOMPOSITE_PROP</unmanaged>
+public enum ArithmeticcompositeProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARITHMETICCOMPOSITE_PROP::D2D1_ARITHMETICCOMPOSITE_PROP_COEFFICIENTS"]/*' />
+	/// <unmanaged>D2D1_ARITHMETICCOMPOSITE_PROP_COEFFICIENTS</unmanaged>
+	Coefficients = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARITHMETICCOMPOSITE_PROP::D2D1_ARITHMETICCOMPOSITE_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_ARITHMETICCOMPOSITE_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CROP_PROP"]/*' />
+/// <unmanaged>D2D1_CROP_PROP</unmanaged>
+public enum CropProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CROP_PROP::D2D1_CROP_PROP_RECT"]/*' />
+	/// <unmanaged>D2D1_CROP_PROP_RECT</unmanaged>
+	Rect = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CROP_PROP::D2D1_CROP_PROP_BORDER_MODE"]/*' />
+	/// <unmanaged>D2D1_CROP_PROP_BORDER_MODE</unmanaged>
+	BorderMode = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_PROP"]/*' />
+/// <unmanaged>D2D1_BORDER_PROP</unmanaged>
+public enum BorderProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_PROP::D2D1_BORDER_PROP_EDGE_MODE_X"]/*' />
+	/// <unmanaged>D2D1_BORDER_PROP_EDGE_MODE_X</unmanaged>
+	EdgeModeX = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_PROP::D2D1_BORDER_PROP_EDGE_MODE_Y"]/*' />
+	/// <unmanaged>D2D1_BORDER_PROP_EDGE_MODE_Y</unmanaged>
+	EdgeModeY = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_EDGE_MODE"]/*' />
+/// <unmanaged>D2D1_BORDER_EDGE_MODE</unmanaged>
+public enum BorderEdgeMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_EDGE_MODE::D2D1_BORDER_EDGE_MODE_CLAMP"]/*' />
+	/// <unmanaged>D2D1_BORDER_EDGE_MODE_CLAMP</unmanaged>
+	Clamp = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_EDGE_MODE::D2D1_BORDER_EDGE_MODE_WRAP"]/*' />
+	/// <unmanaged>D2D1_BORDER_EDGE_MODE_WRAP</unmanaged>
+	Wrap = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BORDER_EDGE_MODE::D2D1_BORDER_EDGE_MODE_MIRROR"]/*' />
+	/// <unmanaged>D2D1_BORDER_EDGE_MODE_MIRROR</unmanaged>
+	Mirror = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_PROP"]/*' />
+/// <unmanaged>D2D1_MORPHOLOGY_PROP</unmanaged>
+public enum MorphologyProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_PROP::D2D1_MORPHOLOGY_PROP_MODE"]/*' />
+	/// <unmanaged>D2D1_MORPHOLOGY_PROP_MODE</unmanaged>
+	Mode = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_PROP::D2D1_MORPHOLOGY_PROP_WIDTH"]/*' />
+	/// <unmanaged>D2D1_MORPHOLOGY_PROP_WIDTH</unmanaged>
+	Width = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_PROP::D2D1_MORPHOLOGY_PROP_HEIGHT"]/*' />
+	/// <unmanaged>D2D1_MORPHOLOGY_PROP_HEIGHT</unmanaged>
+	Height = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_MODE"]/*' />
+/// <unmanaged>D2D1_MORPHOLOGY_MODE</unmanaged>
+public enum MorphologyMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_MODE::D2D1_MORPHOLOGY_MODE_ERODE"]/*' />
+	/// <unmanaged>D2D1_MORPHOLOGY_MODE_ERODE</unmanaged>
+	Erode = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MORPHOLOGY_MODE::D2D1_MORPHOLOGY_MODE_DILATE"]/*' />
+	/// <unmanaged>D2D1_MORPHOLOGY_MODE_DILATE</unmanaged>
+	Dilate = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TILE_PROP"]/*' />
+/// <unmanaged>D2D1_TILE_PROP</unmanaged>
+public enum TileProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TILE_PROP::D2D1_TILE_PROP_RECT"]/*' />
+	/// <unmanaged>D2D1_TILE_PROP_RECT</unmanaged>
+	Rect = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ATLAS_PROP"]/*' />
+/// <unmanaged>D2D1_ATLAS_PROP</unmanaged>
+public enum AtlasProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ATLAS_PROP::D2D1_ATLAS_PROP_INPUT_RECT"]/*' />
+	/// <unmanaged>D2D1_ATLAS_PROP_INPUT_RECT</unmanaged>
+	InputRect = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ATLAS_PROP::D2D1_ATLAS_PROP_INPUT_PADDING_RECT"]/*' />
+	/// <unmanaged>D2D1_ATLAS_PROP_INPUT_PADDING_RECT</unmanaged>
+	InputPaddingRect = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITYMETADATA_PROP"]/*' />
+/// <unmanaged>D2D1_OPACITYMETADATA_PROP</unmanaged>
+public enum OpacitymetadataProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITYMETADATA_PROP::D2D1_OPACITYMETADATA_PROP_INPUT_OPAQUE_RECT"]/*' />
+	/// <unmanaged>D2D1_OPACITYMETADATA_PROP_INPUT_OPAQUE_RECT</unmanaged>
+	InputOpaqueRect = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE"]/*' />
+/// <unmanaged>D2D1_PROPERTY_TYPE</unmanaged>
+public enum PropertyType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_UNKNOWN"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_UNKNOWN</unmanaged>
+	Unknown = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_STRING"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_STRING</unmanaged>
+	String = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_BOOL"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_BOOL</unmanaged>
+	Bool = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_UINT32"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_UINT32</unmanaged>
+	Uint32 = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_INT32"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_INT32</unmanaged>
+	Int32 = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_FLOAT"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_FLOAT</unmanaged>
+	Float = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_VECTOR2"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_VECTOR2</unmanaged>
+	Vector2 = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_VECTOR3"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_VECTOR3</unmanaged>
+	Vector3 = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_VECTOR4"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_VECTOR4</unmanaged>
+	Vector4 = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_BLOB"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_BLOB</unmanaged>
+	Blob = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_IUNKNOWN"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_IUNKNOWN</unmanaged>
+	Iunknown = 10,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_ENUM"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_ENUM</unmanaged>
+	Enum = 11,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_ARRAY"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_ARRAY</unmanaged>
+	Array = 12,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_CLSID"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_CLSID</unmanaged>
+	Clsid = 13,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_MATRIX_3X2"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_MATRIX_3X2</unmanaged>
+	Matrix3x2 = 14,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_MATRIX_4X3"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_MATRIX_4X3</unmanaged>
+	Matrix4x3 = 15,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_MATRIX_4X4"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_MATRIX_4X4</unmanaged>
+	Matrix4x4 = 16,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_MATRIX_5X4"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_MATRIX_5X4</unmanaged>
+	Matrix5x4 = 17,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_TYPE::D2D1_PROPERTY_TYPE_COLOR_CONTEXT"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_TYPE_COLOR_CONTEXT</unmanaged>
+	ColorContext = 18,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY"]/*' />
+/// <unmanaged>D2D1_PROPERTY</unmanaged>
+public enum Property : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_CLSID"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_CLSID</unmanaged>
+	Clsid = 2147483648,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_DISPLAYNAME"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_DISPLAYNAME</unmanaged>
+	Displayname = 2147483649,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_AUTHOR"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_AUTHOR</unmanaged>
+	Author = 2147483650,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_CATEGORY"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_CATEGORY</unmanaged>
+	Category = 2147483651,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_DESCRIPTION"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_DESCRIPTION</unmanaged>
+	Description = 2147483652,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_INPUTS"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_INPUTS</unmanaged>
+	Inputs = 2147483653,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_CACHED"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_CACHED</unmanaged>
+	Cached = 2147483654,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_PRECISION"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_PRECISION</unmanaged>
+	Precision = 2147483655,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_MIN_INPUTS"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_MIN_INPUTS</unmanaged>
+	MinInputs = 2147483656,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY::D2D1_PROPERTY_MAX_INPUTS"]/*' />
+	/// <unmanaged>D2D1_PROPERTY_MAX_INPUTS</unmanaged>
+	MaxInputs = 2147483657,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY"]/*' />
+/// <unmanaged>D2D1_SUBPROPERTY</unmanaged>
+public enum Subproperty : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_DISPLAYNAME"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_DISPLAYNAME</unmanaged>
+	Displayname = 2147483648,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_ISREADONLY"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_ISREADONLY</unmanaged>
+	Isreadonly = 2147483649,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_MIN"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_MIN</unmanaged>
+	Min = 2147483650,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_MAX"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_MAX</unmanaged>
+	Max = 2147483651,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_DEFAULT</unmanaged>
+	Default = 2147483652,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_FIELDS"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_FIELDS</unmanaged>
+	Fields = 2147483653,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SUBPROPERTY::D2D1_SUBPROPERTY_INDEX"]/*' />
+	/// <unmanaged>D2D1_SUBPROPERTY_INDEX</unmanaged>
+	Index = 2147483654,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_OPTIONS"]/*' />
+/// <unmanaged>D2D1_BITMAP_OPTIONS</unmanaged>
+[Flags]
+public enum BitmapOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_OPTIONS::D2D1_BITMAP_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_BITMAP_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_OPTIONS::D2D1_BITMAP_OPTIONS_TARGET"]/*' />
+	/// <unmanaged>D2D1_BITMAP_OPTIONS_TARGET</unmanaged>
+	Target = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_OPTIONS::D2D1_BITMAP_OPTIONS_CANNOT_DRAW"]/*' />
+	/// <unmanaged>D2D1_BITMAP_OPTIONS_CANNOT_DRAW</unmanaged>
+	CannotDraw = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_OPTIONS::D2D1_BITMAP_OPTIONS_CPU_READ"]/*' />
+	/// <unmanaged>D2D1_BITMAP_OPTIONS_CPU_READ</unmanaged>
+	CpuRead = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_OPTIONS::D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE"]/*' />
+	/// <unmanaged>D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE</unmanaged>
+	GDICompatible = 8,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION"]/*' />
+/// <unmanaged>D2D1_BUFFER_PRECISION</unmanaged>
+public enum BufferPrecision : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION::D2D1_BUFFER_PRECISION_UNKNOWN"]/*' />
+	/// <unmanaged>D2D1_BUFFER_PRECISION_UNKNOWN</unmanaged>
+	Unknown = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION::D2D1_BUFFER_PRECISION_8BPC_UNORM"]/*' />
+	/// <unmanaged>D2D1_BUFFER_PRECISION_8BPC_UNORM</unmanaged>
+	_8bpcUnorm = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION::D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB"]/*' />
+	/// <unmanaged>D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB</unmanaged>
+	_8bpcUnormSrgb = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION::D2D1_BUFFER_PRECISION_16BPC_UNORM"]/*' />
+	/// <unmanaged>D2D1_BUFFER_PRECISION_16BPC_UNORM</unmanaged>
+	_16bpcUnorm = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION::D2D1_BUFFER_PRECISION_16BPC_FLOAT"]/*' />
+	/// <unmanaged>D2D1_BUFFER_PRECISION_16BPC_FLOAT</unmanaged>
+	_16bpcFloat = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BUFFER_PRECISION::D2D1_BUFFER_PRECISION_32BPC_FLOAT"]/*' />
+	/// <unmanaged>D2D1_BUFFER_PRECISION_32BPC_FLOAT</unmanaged>
+	_32bpcFloat = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAP_OPTIONS"]/*' />
+/// <unmanaged>D2D1_MAP_OPTIONS</unmanaged>
+[Flags]
+public enum MapOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAP_OPTIONS::D2D1_MAP_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_MAP_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAP_OPTIONS::D2D1_MAP_OPTIONS_READ"]/*' />
+	/// <unmanaged>D2D1_MAP_OPTIONS_READ</unmanaged>
+	Read = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAP_OPTIONS::D2D1_MAP_OPTIONS_WRITE"]/*' />
+	/// <unmanaged>D2D1_MAP_OPTIONS_WRITE</unmanaged>
+	Write = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAP_OPTIONS::D2D1_MAP_OPTIONS_DISCARD"]/*' />
+	/// <unmanaged>D2D1_MAP_OPTIONS_DISCARD</unmanaged>
+	Discard = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_INTERPOLATION_MODE</unmanaged>
+public enum InterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE::D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE::D2D1_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE::D2D1_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE::D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE::D2D1_INTERPOLATION_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INTERPOLATION_MODE::D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_UNIT_MODE"]/*' />
+/// <unmanaged>D2D1_UNIT_MODE</unmanaged>
+public enum UnitMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_UNIT_MODE::D2D1_UNIT_MODE_DIPS"]/*' />
+	/// <unmanaged>D2D1_UNIT_MODE_DIPS</unmanaged>
+	Dips = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_UNIT_MODE::D2D1_UNIT_MODE_PIXELS"]/*' />
+	/// <unmanaged>D2D1_UNIT_MODE_PIXELS</unmanaged>
+	Pixels = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_SPACE"]/*' />
+/// <unmanaged>D2D1_COLOR_SPACE</unmanaged>
+public enum ColorSpace : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_SPACE::D2D1_COLOR_SPACE_CUSTOM"]/*' />
+	/// <unmanaged>D2D1_COLOR_SPACE_CUSTOM</unmanaged>
+	Custom = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_SPACE::D2D1_COLOR_SPACE_SRGB"]/*' />
+	/// <unmanaged>D2D1_COLOR_SPACE_SRGB</unmanaged>
+	Srgb = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_SPACE::D2D1_COLOR_SPACE_SCRGB"]/*' />
+	/// <unmanaged>D2D1_COLOR_SPACE_SCRGB</unmanaged>
+	Scrgb = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEVICE_CONTEXT_OPTIONS"]/*' />
+/// <unmanaged>D2D1_DEVICE_CONTEXT_OPTIONS</unmanaged>
+[Flags]
+public enum DeviceContextOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEVICE_CONTEXT_OPTIONS::D2D1_DEVICE_CONTEXT_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_DEVICE_CONTEXT_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DEVICE_CONTEXT_OPTIONS::D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS"]/*' />
+	/// <unmanaged>D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS</unmanaged>
+	EnableMultithreadedOptimizations = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_TRANSFORM_TYPE"]/*' />
+/// <unmanaged>D2D1_STROKE_TRANSFORM_TYPE</unmanaged>
+public enum StrokeTransformType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_TRANSFORM_TYPE::D2D1_STROKE_TRANSFORM_TYPE_NORMAL"]/*' />
+	/// <unmanaged>D2D1_STROKE_TRANSFORM_TYPE_NORMAL</unmanaged>
+	Normal = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_TRANSFORM_TYPE::D2D1_STROKE_TRANSFORM_TYPE_FIXED"]/*' />
+	/// <unmanaged>D2D1_STROKE_TRANSFORM_TYPE_FIXED</unmanaged>
+	Fixed = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_TRANSFORM_TYPE::D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE"]/*' />
+	/// <unmanaged>D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE</unmanaged>
+	Hairline = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRIMITIVE_BLEND"]/*' />
+/// <unmanaged>D2D1_PRIMITIVE_BLEND</unmanaged>
+public enum PrimitiveBlend : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRIMITIVE_BLEND::D2D1_PRIMITIVE_BLEND_SOURCE_OVER"]/*' />
+	/// <unmanaged>D2D1_PRIMITIVE_BLEND_SOURCE_OVER</unmanaged>
+	SourceOver = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRIMITIVE_BLEND::D2D1_PRIMITIVE_BLEND_COPY"]/*' />
+	/// <unmanaged>D2D1_PRIMITIVE_BLEND_COPY</unmanaged>
+	Copy = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRIMITIVE_BLEND::D2D1_PRIMITIVE_BLEND_MIN"]/*' />
+	/// <unmanaged>D2D1_PRIMITIVE_BLEND_MIN</unmanaged>
+	Min = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRIMITIVE_BLEND::D2D1_PRIMITIVE_BLEND_ADD"]/*' />
+	/// <unmanaged>D2D1_PRIMITIVE_BLEND_ADD</unmanaged>
+	Add = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRIMITIVE_BLEND::D2D1_PRIMITIVE_BLEND_MAX"]/*' />
+	/// <unmanaged>D2D1_PRIMITIVE_BLEND_MAX</unmanaged>
+	Max = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_THREADING_MODE"]/*' />
+/// <unmanaged>D2D1_THREADING_MODE</unmanaged>
+public enum ThreadingMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_THREADING_MODE::D2D1_THREADING_MODE_SINGLE_THREADED"]/*' />
+	/// <unmanaged>D2D1_THREADING_MODE_SINGLE_THREADED</unmanaged>
+	SingleThreaded = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_THREADING_MODE::D2D1_THREADING_MODE_MULTI_THREADED"]/*' />
+	/// <unmanaged>D2D1_THREADING_MODE_MULTI_THREADED</unmanaged>
+	MultiThreaded = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_COLOR_INTERPOLATION_MODE</unmanaged>
+public enum ColorInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_INTERPOLATION_MODE::D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT"]/*' />
+	/// <unmanaged>D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT</unmanaged>
+	Straight = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_INTERPOLATION_MODE::D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED"]/*' />
+	/// <unmanaged>D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED</unmanaged>
+	Premultiplied = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS1"]/*' />
+/// <unmanaged>D2D1_LAYER_OPTIONS1</unmanaged>
+[Flags]
+public enum LayerOptions1 : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS1::D2D1_LAYER_OPTIONS1_NONE"]/*' />
+	/// <unmanaged>D2D1_LAYER_OPTIONS1_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS1::D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND"]/*' />
+	/// <unmanaged>D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND</unmanaged>
+	InitializeFromBackground = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_OPTIONS1::D2D1_LAYER_OPTIONS1_IGNORE_ALPHA"]/*' />
+	/// <unmanaged>D2D1_LAYER_OPTIONS1_IGNORE_ALPHA</unmanaged>
+	IgnoreAlpha = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_FONT_SUBSET_MODE"]/*' />
+/// <unmanaged>D2D1_PRINT_FONT_SUBSET_MODE</unmanaged>
+public enum PrintFontSubsetMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_FONT_SUBSET_MODE::D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT</unmanaged>
+	Default = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_FONT_SUBSET_MODE::D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE"]/*' />
+	/// <unmanaged>D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE</unmanaged>
+	Eachpage = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_FONT_SUBSET_MODE::D2D1_PRINT_FONT_SUBSET_MODE_NONE"]/*' />
+	/// <unmanaged>D2D1_PRINT_FONT_SUBSET_MODE_NONE</unmanaged>
+	None = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANGE_TYPE"]/*' />
+/// <unmanaged>D2D1_CHANGE_TYPE</unmanaged>
+[Flags]
+public enum ChangeType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANGE_TYPE::D2D1_CHANGE_TYPE_NONE"]/*' />
+	/// <unmanaged>D2D1_CHANGE_TYPE_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANGE_TYPE::D2D1_CHANGE_TYPE_PROPERTIES"]/*' />
+	/// <unmanaged>D2D1_CHANGE_TYPE_PROPERTIES</unmanaged>
+	Properties = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANGE_TYPE::D2D1_CHANGE_TYPE_CONTEXT"]/*' />
+	/// <unmanaged>D2D1_CHANGE_TYPE_CONTEXT</unmanaged>
+	Context = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANGE_TYPE::D2D1_CHANGE_TYPE_GRAPH"]/*' />
+	/// <unmanaged>D2D1_CHANGE_TYPE_GRAPH</unmanaged>
+	Graph = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PIXEL_OPTIONS"]/*' />
+/// <unmanaged>D2D1_PIXEL_OPTIONS</unmanaged>
+[Flags]
+public enum PixelOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PIXEL_OPTIONS::D2D1_PIXEL_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_PIXEL_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PIXEL_OPTIONS::D2D1_PIXEL_OPTIONS_TRIVIAL_SAMPLING"]/*' />
+	/// <unmanaged>D2D1_PIXEL_OPTIONS_TRIVIAL_SAMPLING</unmanaged>
+	TrivialSampling = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_OPTIONS"]/*' />
+/// <unmanaged>D2D1_VERTEX_OPTIONS</unmanaged>
+[Flags]
+public enum VertexOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_OPTIONS::D2D1_VERTEX_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_VERTEX_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_OPTIONS::D2D1_VERTEX_OPTIONS_DO_NOT_CLEAR"]/*' />
+	/// <unmanaged>D2D1_VERTEX_OPTIONS_DO_NOT_CLEAR</unmanaged>
+	DoNotClear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_OPTIONS::D2D1_VERTEX_OPTIONS_USE_DEPTH_BUFFER"]/*' />
+	/// <unmanaged>D2D1_VERTEX_OPTIONS_USE_DEPTH_BUFFER</unmanaged>
+	UseDepthBuffer = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_OPTIONS::D2D1_VERTEX_OPTIONS_ASSUME_NO_OVERLAP"]/*' />
+	/// <unmanaged>D2D1_VERTEX_OPTIONS_ASSUME_NO_OVERLAP</unmanaged>
+	AssumeNoOverlap = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_USAGE"]/*' />
+/// <unmanaged>D2D1_VERTEX_USAGE</unmanaged>
+public enum VertexUsage : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_USAGE::D2D1_VERTEX_USAGE_STATIC"]/*' />
+	/// <unmanaged>D2D1_VERTEX_USAGE_STATIC</unmanaged>
+	Static = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_USAGE::D2D1_VERTEX_USAGE_DYNAMIC"]/*' />
+	/// <unmanaged>D2D1_VERTEX_USAGE_DYNAMIC</unmanaged>
+	Dynamic = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_OPERATION"]/*' />
+/// <unmanaged>D2D1_BLEND_OPERATION</unmanaged>
+public enum BlendOperation : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_OPERATION::D2D1_BLEND_OPERATION_ADD"]/*' />
+	/// <unmanaged>D2D1_BLEND_OPERATION_ADD</unmanaged>
+	Add = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_OPERATION::D2D1_BLEND_OPERATION_SUBTRACT"]/*' />
+	/// <unmanaged>D2D1_BLEND_OPERATION_SUBTRACT</unmanaged>
+	Subtract = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_OPERATION::D2D1_BLEND_OPERATION_REV_SUBTRACT"]/*' />
+	/// <unmanaged>D2D1_BLEND_OPERATION_REV_SUBTRACT</unmanaged>
+	RevSubtract = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_OPERATION::D2D1_BLEND_OPERATION_MIN"]/*' />
+	/// <unmanaged>D2D1_BLEND_OPERATION_MIN</unmanaged>
+	Min = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_OPERATION::D2D1_BLEND_OPERATION_MAX"]/*' />
+	/// <unmanaged>D2D1_BLEND_OPERATION_MAX</unmanaged>
+	Max = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND"]/*' />
+/// <unmanaged>D2D1_BLEND</unmanaged>
+public enum Blend : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_ZERO"]/*' />
+	/// <unmanaged>D2D1_BLEND_ZERO</unmanaged>
+	Zero = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_ONE"]/*' />
+	/// <unmanaged>D2D1_BLEND_ONE</unmanaged>
+	One = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_SRC_COLOR"]/*' />
+	/// <unmanaged>D2D1_BLEND_SRC_COLOR</unmanaged>
+	SrcColor = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_INV_SRC_COLOR"]/*' />
+	/// <unmanaged>D2D1_BLEND_INV_SRC_COLOR</unmanaged>
+	InvSrcColor = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_SRC_ALPHA"]/*' />
+	/// <unmanaged>D2D1_BLEND_SRC_ALPHA</unmanaged>
+	SrcAlpha = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_INV_SRC_ALPHA"]/*' />
+	/// <unmanaged>D2D1_BLEND_INV_SRC_ALPHA</unmanaged>
+	InvSrcAlpha = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_DEST_ALPHA"]/*' />
+	/// <unmanaged>D2D1_BLEND_DEST_ALPHA</unmanaged>
+	DestAlpha = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_INV_DEST_ALPHA"]/*' />
+	/// <unmanaged>D2D1_BLEND_INV_DEST_ALPHA</unmanaged>
+	InvDestAlpha = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_DEST_COLOR"]/*' />
+	/// <unmanaged>D2D1_BLEND_DEST_COLOR</unmanaged>
+	DestColor = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_INV_DEST_COLOR"]/*' />
+	/// <unmanaged>D2D1_BLEND_INV_DEST_COLOR</unmanaged>
+	InvDestColor = 10,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_SRC_ALPHA_SAT"]/*' />
+	/// <unmanaged>D2D1_BLEND_SRC_ALPHA_SAT</unmanaged>
+	SrcAlphaSat = 11,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_BLEND_FACTOR"]/*' />
+	/// <unmanaged>D2D1_BLEND_BLEND_FACTOR</unmanaged>
+	BlendFactor = 14,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND::D2D1_BLEND_INV_BLEND_FACTOR"]/*' />
+	/// <unmanaged>D2D1_BLEND_INV_BLEND_FACTOR</unmanaged>
+	InvBlendFactor = 15,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_DEPTH"]/*' />
+/// <unmanaged>D2D1_CHANNEL_DEPTH</unmanaged>
+public enum ChannelDepth : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_DEPTH::D2D1_CHANNEL_DEPTH_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_DEPTH_DEFAULT</unmanaged>
+	Default = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_DEPTH::D2D1_CHANNEL_DEPTH_1"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_DEPTH_1</unmanaged>
+	_1 = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHANNEL_DEPTH::D2D1_CHANNEL_DEPTH_4"]/*' />
+	/// <unmanaged>D2D1_CHANNEL_DEPTH_4</unmanaged>
+	_4 = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER"]/*' />
+/// <unmanaged>D2D1_FILTER</unmanaged>
+public enum Filter : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_MAG_MIP_POINT"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_MAG_MIP_POINT</unmanaged>
+	MinMagMipPoint = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_MAG_POINT_MIP_LINEAR"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_MAG_POINT_MIP_LINEAR</unmanaged>
+	MinMagPointMipLinear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT</unmanaged>
+	MinPointMagLinearMipPoint = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_POINT_MAG_MIP_LINEAR"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_POINT_MAG_MIP_LINEAR</unmanaged>
+	MinPointMagMipLinear = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_LINEAR_MAG_MIP_POINT"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_LINEAR_MAG_MIP_POINT</unmanaged>
+	MinLinearMagMipPoint = 16,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR</unmanaged>
+	MinLinearMagPointMipLinear = 17,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_MAG_LINEAR_MIP_POINT"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_MAG_LINEAR_MIP_POINT</unmanaged>
+	MinMagLinearMipPoint = 20,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_MIN_MAG_MIP_LINEAR"]/*' />
+	/// <unmanaged>D2D1_FILTER_MIN_MAG_MIP_LINEAR</unmanaged>
+	MinMagMipLinear = 21,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FILTER::D2D1_FILTER_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_FILTER_ANISOTROPIC</unmanaged>
+	Anisotropic = 85,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE"]/*' />
+/// <unmanaged>D2D1_FEATURE</unmanaged>
+public enum Feature : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE::D2D1_FEATURE_DOUBLES"]/*' />
+	/// <unmanaged>D2D1_FEATURE_DOUBLES</unmanaged>
+	Doubles = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE::D2D1_FEATURE_D3D10_X_HARDWARE_OPTIONS"]/*' />
+	/// <unmanaged>D2D1_FEATURE_D3D10_X_HARDWARE_OPTIONS</unmanaged>
+	XHardwareOptions = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_PROP"]/*' />
+/// <unmanaged>D2D1_YCBCR_PROP</unmanaged>
+public enum YcbcrProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_PROP::D2D1_YCBCR_PROP_CHROMA_SUBSAMPLING"]/*' />
+	/// <unmanaged>D2D1_YCBCR_PROP_CHROMA_SUBSAMPLING</unmanaged>
+	ChromaSubsampling = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_PROP::D2D1_YCBCR_PROP_TRANSFORM_MATRIX"]/*' />
+	/// <unmanaged>D2D1_YCBCR_PROP_TRANSFORM_MATRIX</unmanaged>
+	TransformMatrix = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_PROP::D2D1_YCBCR_PROP_INTERPOLATION_MODE"]/*' />
+	/// <unmanaged>D2D1_YCBCR_PROP_INTERPOLATION_MODE</unmanaged>
+	InterpolationMode = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_CHROMA_SUBSAMPLING"]/*' />
+/// <unmanaged>D2D1_YCBCR_CHROMA_SUBSAMPLING</unmanaged>
+public enum YcbcrChromaSubsampling : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_CHROMA_SUBSAMPLING::D2D1_YCBCR_CHROMA_SUBSAMPLING_AUTO"]/*' />
+	/// <unmanaged>D2D1_YCBCR_CHROMA_SUBSAMPLING_AUTO</unmanaged>
+	Auto = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_CHROMA_SUBSAMPLING::D2D1_YCBCR_CHROMA_SUBSAMPLING_420"]/*' />
+	/// <unmanaged>D2D1_YCBCR_CHROMA_SUBSAMPLING_420</unmanaged>
+	_420 = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_CHROMA_SUBSAMPLING::D2D1_YCBCR_CHROMA_SUBSAMPLING_422"]/*' />
+	/// <unmanaged>D2D1_YCBCR_CHROMA_SUBSAMPLING_422</unmanaged>
+	_422 = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_CHROMA_SUBSAMPLING::D2D1_YCBCR_CHROMA_SUBSAMPLING_444"]/*' />
+	/// <unmanaged>D2D1_YCBCR_CHROMA_SUBSAMPLING_444</unmanaged>
+	_444 = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_CHROMA_SUBSAMPLING::D2D1_YCBCR_CHROMA_SUBSAMPLING_440"]/*' />
+	/// <unmanaged>D2D1_YCBCR_CHROMA_SUBSAMPLING_440</unmanaged>
+	_440 = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE"]/*' />
+/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE</unmanaged>
+public enum YcbcrInterpolationMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE::D2D1_YCBCR_INTERPOLATION_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE::D2D1_YCBCR_INTERPOLATION_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE::D2D1_YCBCR_INTERPOLATION_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE::D2D1_YCBCR_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE::D2D1_YCBCR_INTERPOLATION_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_YCBCR_INTERPOLATION_MODE::D2D1_YCBCR_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC"]/*' />
+	/// <unmanaged>D2D1_YCBCR_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC</unmanaged>
+	HighQualityCubic = 5,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONTRAST_PROP"]/*' />
+/// <unmanaged>D2D1_CONTRAST_PROP</unmanaged>
+public enum ContrastProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONTRAST_PROP::D2D1_CONTRAST_PROP_CONTRAST"]/*' />
+	/// <unmanaged>D2D1_CONTRAST_PROP_CONTRAST</unmanaged>
+	Contrast = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CONTRAST_PROP::D2D1_CONTRAST_PROP_CLAMP_INPUT"]/*' />
+	/// <unmanaged>D2D1_CONTRAST_PROP_CLAMP_INPUT</unmanaged>
+	ClampInput = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RGBTOHUE_PROP"]/*' />
+/// <unmanaged>D2D1_RGBTOHUE_PROP</unmanaged>
+public enum RgbtohueProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RGBTOHUE_PROP::D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE"]/*' />
+	/// <unmanaged>D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE</unmanaged>
+	OutputColorSpace = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE"]/*' />
+/// <unmanaged>D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE</unmanaged>
+public enum RgbtohueOutputColorSpace : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE::D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE"]/*' />
+	/// <unmanaged>D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE</unmanaged>
+	HueSaturationValue = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE::D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS"]/*' />
+	/// <unmanaged>D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS</unmanaged>
+	HueSaturationLightness = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUETORGB_PROP"]/*' />
+/// <unmanaged>D2D1_HUETORGB_PROP</unmanaged>
+public enum HuetorgbProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUETORGB_PROP::D2D1_HUETORGB_PROP_INPUT_COLOR_SPACE"]/*' />
+	/// <unmanaged>D2D1_HUETORGB_PROP_INPUT_COLOR_SPACE</unmanaged>
+	InputColorSpace = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUETORGB_INPUT_COLOR_SPACE"]/*' />
+/// <unmanaged>D2D1_HUETORGB_INPUT_COLOR_SPACE</unmanaged>
+public enum HuetorgbInputColorSpace : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUETORGB_INPUT_COLOR_SPACE::D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_VALUE"]/*' />
+	/// <unmanaged>D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_VALUE</unmanaged>
+	HueSaturationValue = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HUETORGB_INPUT_COLOR_SPACE::D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS"]/*' />
+	/// <unmanaged>D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS</unmanaged>
+	HueSaturationLightness = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHROMAKEY_PROP"]/*' />
+/// <unmanaged>D2D1_CHROMAKEY_PROP</unmanaged>
+public enum ChromakeyProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHROMAKEY_PROP::D2D1_CHROMAKEY_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_CHROMAKEY_PROP_COLOR</unmanaged>
+	Color = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHROMAKEY_PROP::D2D1_CHROMAKEY_PROP_TOLERANCE"]/*' />
+	/// <unmanaged>D2D1_CHROMAKEY_PROP_TOLERANCE</unmanaged>
+	Tolerance = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHROMAKEY_PROP::D2D1_CHROMAKEY_PROP_INVERT_ALPHA"]/*' />
+	/// <unmanaged>D2D1_CHROMAKEY_PROP_INVERT_ALPHA</unmanaged>
+	InvertAlpha = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CHROMAKEY_PROP::D2D1_CHROMAKEY_PROP_FEATHER"]/*' />
+	/// <unmanaged>D2D1_CHROMAKEY_PROP_FEATHER</unmanaged>
+	Feather = 3,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EMBOSS_PROP"]/*' />
+/// <unmanaged>D2D1_EMBOSS_PROP</unmanaged>
+public enum EmbossProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EMBOSS_PROP::D2D1_EMBOSS_PROP_HEIGHT"]/*' />
+	/// <unmanaged>D2D1_EMBOSS_PROP_HEIGHT</unmanaged>
+	Height = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EMBOSS_PROP::D2D1_EMBOSS_PROP_DIRECTION"]/*' />
+	/// <unmanaged>D2D1_EMBOSS_PROP_DIRECTION</unmanaged>
+	Direction = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EXPOSURE_PROP"]/*' />
+/// <unmanaged>D2D1_EXPOSURE_PROP</unmanaged>
+public enum ExposureProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EXPOSURE_PROP::D2D1_EXPOSURE_PROP_EXPOSURE_VALUE"]/*' />
+	/// <unmanaged>D2D1_EXPOSURE_PROP_EXPOSURE_VALUE</unmanaged>
+	ExposureValue = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POSTERIZE_PROP"]/*' />
+/// <unmanaged>D2D1_POSTERIZE_PROP</unmanaged>
+public enum PosterizeProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POSTERIZE_PROP::D2D1_POSTERIZE_PROP_RED_VALUE_COUNT"]/*' />
+	/// <unmanaged>D2D1_POSTERIZE_PROP_RED_VALUE_COUNT</unmanaged>
+	RedValueCount = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POSTERIZE_PROP::D2D1_POSTERIZE_PROP_GREEN_VALUE_COUNT"]/*' />
+	/// <unmanaged>D2D1_POSTERIZE_PROP_GREEN_VALUE_COUNT</unmanaged>
+	GreenValueCount = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POSTERIZE_PROP::D2D1_POSTERIZE_PROP_BLUE_VALUE_COUNT"]/*' />
+	/// <unmanaged>D2D1_POSTERIZE_PROP_BLUE_VALUE_COUNT</unmanaged>
+	BlueValueCount = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SEPIA_PROP"]/*' />
+/// <unmanaged>D2D1_SEPIA_PROP</unmanaged>
+public enum SepiaProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SEPIA_PROP::D2D1_SEPIA_PROP_INTENSITY"]/*' />
+	/// <unmanaged>D2D1_SEPIA_PROP_INTENSITY</unmanaged>
+	Intensity = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SEPIA_PROP::D2D1_SEPIA_PROP_ALPHA_MODE"]/*' />
+	/// <unmanaged>D2D1_SEPIA_PROP_ALPHA_MODE</unmanaged>
+	AlphaMode = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHARPEN_PROP"]/*' />
+/// <unmanaged>D2D1_SHARPEN_PROP</unmanaged>
+public enum SharpenProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHARPEN_PROP::D2D1_SHARPEN_PROP_SHARPNESS"]/*' />
+	/// <unmanaged>D2D1_SHARPEN_PROP_SHARPNESS</unmanaged>
+	Sharpness = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SHARPEN_PROP::D2D1_SHARPEN_PROP_THRESHOLD"]/*' />
+	/// <unmanaged>D2D1_SHARPEN_PROP_THRESHOLD</unmanaged>
+	Threshold = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_PROP"]/*' />
+/// <unmanaged>D2D1_STRAIGHTEN_PROP</unmanaged>
+public enum StraightenProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_PROP::D2D1_STRAIGHTEN_PROP_ANGLE"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_PROP_ANGLE</unmanaged>
+	Angle = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_PROP::D2D1_STRAIGHTEN_PROP_MAINTAIN_SIZE"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_PROP_MAINTAIN_SIZE</unmanaged>
+	MaintainSize = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_PROP::D2D1_STRAIGHTEN_PROP_SCALE_MODE"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_PROP_SCALE_MODE</unmanaged>
+	ScaleMode = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_SCALE_MODE"]/*' />
+/// <unmanaged>D2D1_STRAIGHTEN_SCALE_MODE</unmanaged>
+public enum StraightenScaleMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_SCALE_MODE::D2D1_STRAIGHTEN_SCALE_MODE_NEAREST_NEIGHBOR"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_SCALE_MODE_NEAREST_NEIGHBOR</unmanaged>
+	NearestNeighbor = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_SCALE_MODE::D2D1_STRAIGHTEN_SCALE_MODE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_SCALE_MODE_LINEAR</unmanaged>
+	Linear = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_SCALE_MODE::D2D1_STRAIGHTEN_SCALE_MODE_CUBIC"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_SCALE_MODE_CUBIC</unmanaged>
+	Cubic = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_SCALE_MODE::D2D1_STRAIGHTEN_SCALE_MODE_MULTI_SAMPLE_LINEAR"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_SCALE_MODE_MULTI_SAMPLE_LINEAR</unmanaged>
+	MultiSampleLinear = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STRAIGHTEN_SCALE_MODE::D2D1_STRAIGHTEN_SCALE_MODE_ANISOTROPIC"]/*' />
+	/// <unmanaged>D2D1_STRAIGHTEN_SCALE_MODE_ANISOTROPIC</unmanaged>
+	Anisotropic = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEMPERATUREANDTINT_PROP"]/*' />
+/// <unmanaged>D2D1_TEMPERATUREANDTINT_PROP</unmanaged>
+public enum TemperatureandtintProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEMPERATUREANDTINT_PROP::D2D1_TEMPERATUREANDTINT_PROP_TEMPERATURE"]/*' />
+	/// <unmanaged>D2D1_TEMPERATUREANDTINT_PROP_TEMPERATURE</unmanaged>
+	Temperature = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TEMPERATUREANDTINT_PROP::D2D1_TEMPERATUREANDTINT_PROP_TINT"]/*' />
+	/// <unmanaged>D2D1_TEMPERATUREANDTINT_PROP_TINT</unmanaged>
+	Tint = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VIGNETTE_PROP"]/*' />
+/// <unmanaged>D2D1_VIGNETTE_PROP</unmanaged>
+public enum VignetteProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VIGNETTE_PROP::D2D1_VIGNETTE_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_VIGNETTE_PROP_COLOR</unmanaged>
+	Color = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VIGNETTE_PROP::D2D1_VIGNETTE_PROP_TRANSITION_SIZE"]/*' />
+	/// <unmanaged>D2D1_VIGNETTE_PROP_TRANSITION_SIZE</unmanaged>
+	TransitionSize = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VIGNETTE_PROP::D2D1_VIGNETTE_PROP_STRENGTH"]/*' />
+	/// <unmanaged>D2D1_VIGNETTE_PROP_STRENGTH</unmanaged>
+	Strength = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_PROP"]/*' />
+/// <unmanaged>D2D1_EDGEDETECTION_PROP</unmanaged>
+public enum EdgedetectionProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_PROP::D2D1_EDGEDETECTION_PROP_STRENGTH"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_PROP_STRENGTH</unmanaged>
+	Strength = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_PROP::D2D1_EDGEDETECTION_PROP_BLUR_RADIUS"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_PROP_BLUR_RADIUS</unmanaged>
+	BlurRadius = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_PROP::D2D1_EDGEDETECTION_PROP_MODE"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_PROP_MODE</unmanaged>
+	Mode = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_PROP::D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES</unmanaged>
+	OverlayEdges = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_PROP::D2D1_EDGEDETECTION_PROP_ALPHA_MODE"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_PROP_ALPHA_MODE</unmanaged>
+	AlphaMode = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_MODE"]/*' />
+/// <unmanaged>D2D1_EDGEDETECTION_MODE</unmanaged>
+public enum EdgedetectionMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_MODE::D2D1_EDGEDETECTION_MODE_SOBEL"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_MODE_SOBEL</unmanaged>
+	Sobel = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EDGEDETECTION_MODE::D2D1_EDGEDETECTION_MODE_PREWITT"]/*' />
+	/// <unmanaged>D2D1_EDGEDETECTION_MODE_PREWITT</unmanaged>
+	Prewitt = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_PROP"]/*' />
+/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_PROP</unmanaged>
+public enum HighlightsandshadowsProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_PROP::D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS</unmanaged>
+	Highlights = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_PROP::D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS</unmanaged>
+	Shadows = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_PROP::D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY</unmanaged>
+	Clarity = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_PROP::D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA</unmanaged>
+	InputGamma = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_PROP::D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS</unmanaged>
+	MaskBlurRadius = 4,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA"]/*' />
+/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA</unmanaged>
+public enum HighlightsandshadowsInputGamma : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA::D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR</unmanaged>
+	Linear = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA::D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_SRGB"]/*' />
+	/// <unmanaged>D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_SRGB</unmanaged>
+	Srgb = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LOOKUPTABLE3D_PROP"]/*' />
+/// <unmanaged>D2D1_LOOKUPTABLE3D_PROP</unmanaged>
+public enum Lookuptable3dProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LOOKUPTABLE3D_PROP::D2D1_LOOKUPTABLE3D_PROP_LUT"]/*' />
+	/// <unmanaged>D2D1_LOOKUPTABLE3D_PROP_LUT</unmanaged>
+	Lut = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LOOKUPTABLE3D_PROP::D2D1_LOOKUPTABLE3D_PROP_ALPHA_MODE"]/*' />
+	/// <unmanaged>D2D1_LOOKUPTABLE3D_PROP_ALPHA_MODE</unmanaged>
+	AlphaMode = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITY_PROP"]/*' />
+/// <unmanaged>D2D1_OPACITY_PROP</unmanaged>
+public enum OpacityProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_OPACITY_PROP::D2D1_OPACITY_PROP_OPACITY"]/*' />
+	/// <unmanaged>D2D1_OPACITY_PROP_OPACITY</unmanaged>
+	Opacity = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CROSSFADE_PROP"]/*' />
+/// <unmanaged>D2D1_CROSSFADE_PROP</unmanaged>
+public enum CrossfadeProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CROSSFADE_PROP::D2D1_CROSSFADE_PROP_WEIGHT"]/*' />
+	/// <unmanaged>D2D1_CROSSFADE_PROP_WEIGHT</unmanaged>
+	Weight = 0,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TINT_PROP"]/*' />
+/// <unmanaged>D2D1_TINT_PROP</unmanaged>
+public enum TintProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TINT_PROP::D2D1_TINT_PROP_COLOR"]/*' />
+	/// <unmanaged>D2D1_TINT_PROP_COLOR</unmanaged>
+	Color = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TINT_PROP::D2D1_TINT_PROP_CLAMP_OUTPUT"]/*' />
+	/// <unmanaged>D2D1_TINT_PROP_CLAMP_OUTPUT</unmanaged>
+	ClampOutput = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_WHITELEVELADJUSTMENT_PROP"]/*' />
+/// <unmanaged>D2D1_WHITELEVELADJUSTMENT_PROP</unmanaged>
+public enum WhiteleveladjustmentProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_WHITELEVELADJUSTMENT_PROP::D2D1_WHITELEVELADJUSTMENT_PROP_INPUT_WHITE_LEVEL"]/*' />
+	/// <unmanaged>D2D1_WHITELEVELADJUSTMENT_PROP_INPUT_WHITE_LEVEL</unmanaged>
+	InputWhiteLevel = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_WHITELEVELADJUSTMENT_PROP::D2D1_WHITELEVELADJUSTMENT_PROP_OUTPUT_WHITE_LEVEL"]/*' />
+	/// <unmanaged>D2D1_WHITELEVELADJUSTMENT_PROP_OUTPUT_WHITE_LEVEL</unmanaged>
+	OutputWhiteLevel = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_PROP"]/*' />
+/// <unmanaged>D2D1_HDRTONEMAP_PROP</unmanaged>
+public enum HdrtonemapProp : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_PROP::D2D1_HDRTONEMAP_PROP_INPUT_MAX_LUMINANCE"]/*' />
+	/// <unmanaged>D2D1_HDRTONEMAP_PROP_INPUT_MAX_LUMINANCE</unmanaged>
+	InputMaxLuminance = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_PROP::D2D1_HDRTONEMAP_PROP_OUTPUT_MAX_LUMINANCE"]/*' />
+	/// <unmanaged>D2D1_HDRTONEMAP_PROP_OUTPUT_MAX_LUMINANCE</unmanaged>
+	OutputMaxLuminance = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_PROP::D2D1_HDRTONEMAP_PROP_DISPLAY_MODE"]/*' />
+	/// <unmanaged>D2D1_HDRTONEMAP_PROP_DISPLAY_MODE</unmanaged>
+	DisplayMode = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_DISPLAY_MODE"]/*' />
+/// <unmanaged>D2D1_HDRTONEMAP_DISPLAY_MODE</unmanaged>
+public enum HdrtonemapDisplayMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_DISPLAY_MODE::D2D1_HDRTONEMAP_DISPLAY_MODE_SDR"]/*' />
+	/// <unmanaged>D2D1_HDRTONEMAP_DISPLAY_MODE_SDR</unmanaged>
+	Sdr = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HDRTONEMAP_DISPLAY_MODE::D2D1_HDRTONEMAP_DISPLAY_MODE_HDR"]/*' />
+	/// <unmanaged>D2D1_HDRTONEMAP_DISPLAY_MODE_HDR</unmanaged>
+	Hdr = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDERING_PRIORITY"]/*' />
+/// <unmanaged>D2D1_RENDERING_PRIORITY</unmanaged>
+public enum RenderingPriority : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDERING_PRIORITY::D2D1_RENDERING_PRIORITY_NORMAL"]/*' />
+	/// <unmanaged>D2D1_RENDERING_PRIORITY_NORMAL</unmanaged>
+	Normal = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDERING_PRIORITY::D2D1_RENDERING_PRIORITY_LOW"]/*' />
+	/// <unmanaged>D2D1_RENDERING_PRIORITY_LOW</unmanaged>
+	Low = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE"]/*' />
+/// <unmanaged>D2D1_SVG_PAINT_TYPE</unmanaged>
+public enum SvgPaintType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_NONE"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_COLOR"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_COLOR</unmanaged>
+	Color = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_CURRENT_COLOR"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_CURRENT_COLOR</unmanaged>
+	CurrentColor = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_URI"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_URI</unmanaged>
+	Uri = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_URI_NONE"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_URI_NONE</unmanaged>
+	UriNone = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_URI_COLOR"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_URI_COLOR</unmanaged>
+	UriColor = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PAINT_TYPE::D2D1_SVG_PAINT_TYPE_URI_CURRENT_COLOR"]/*' />
+	/// <unmanaged>D2D1_SVG_PAINT_TYPE_URI_CURRENT_COLOR</unmanaged>
+	UriCurrentColor = 6,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LENGTH_UNITS"]/*' />
+/// <unmanaged>D2D1_SVG_LENGTH_UNITS</unmanaged>
+public enum SvgLengthUnits : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LENGTH_UNITS::D2D1_SVG_LENGTH_UNITS_NUMBER"]/*' />
+	/// <unmanaged>D2D1_SVG_LENGTH_UNITS_NUMBER</unmanaged>
+	Number = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LENGTH_UNITS::D2D1_SVG_LENGTH_UNITS_PERCENTAGE"]/*' />
+	/// <unmanaged>D2D1_SVG_LENGTH_UNITS_PERCENTAGE</unmanaged>
+	Percentage = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_DISPLAY"]/*' />
+/// <unmanaged>D2D1_SVG_DISPLAY</unmanaged>
+public enum SvgDisplay : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_DISPLAY::D2D1_SVG_DISPLAY_INLINE"]/*' />
+	/// <unmanaged>D2D1_SVG_DISPLAY_INLINE</unmanaged>
+	Inline = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_DISPLAY::D2D1_SVG_DISPLAY_NONE"]/*' />
+	/// <unmanaged>D2D1_SVG_DISPLAY_NONE</unmanaged>
+	None = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VISIBILITY"]/*' />
+/// <unmanaged>D2D1_SVG_VISIBILITY</unmanaged>
+public enum SvgVisibility : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VISIBILITY::D2D1_SVG_VISIBILITY_VISIBLE"]/*' />
+	/// <unmanaged>D2D1_SVG_VISIBILITY_VISIBLE</unmanaged>
+	Visible = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VISIBILITY::D2D1_SVG_VISIBILITY_HIDDEN"]/*' />
+	/// <unmanaged>D2D1_SVG_VISIBILITY_HIDDEN</unmanaged>
+	Hidden = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_OVERFLOW"]/*' />
+/// <unmanaged>D2D1_SVG_OVERFLOW</unmanaged>
+public enum SvgOverflow : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_OVERFLOW::D2D1_SVG_OVERFLOW_VISIBLE"]/*' />
+	/// <unmanaged>D2D1_SVG_OVERFLOW_VISIBLE</unmanaged>
+	Visible = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_OVERFLOW::D2D1_SVG_OVERFLOW_HIDDEN"]/*' />
+	/// <unmanaged>D2D1_SVG_OVERFLOW_HIDDEN</unmanaged>
+	Hidden = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_CAP"]/*' />
+/// <unmanaged>D2D1_SVG_LINE_CAP</unmanaged>
+public enum SvgLineCap : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_CAP::D2D1_SVG_LINE_CAP_BUTT"]/*' />
+	/// <unmanaged>D2D1_SVG_LINE_CAP_BUTT</unmanaged>
+	Butt = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_CAP::D2D1_SVG_LINE_CAP_SQUARE"]/*' />
+	/// <unmanaged>D2D1_SVG_LINE_CAP_SQUARE</unmanaged>
+	Square = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_CAP::D2D1_SVG_LINE_CAP_ROUND"]/*' />
+	/// <unmanaged>D2D1_SVG_LINE_CAP_ROUND</unmanaged>
+	Round = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_JOIN"]/*' />
+/// <unmanaged>D2D1_SVG_LINE_JOIN</unmanaged>
+public enum SvgLineJoin : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_JOIN::D2D1_SVG_LINE_JOIN_BEVEL"]/*' />
+	/// <unmanaged>D2D1_SVG_LINE_JOIN_BEVEL</unmanaged>
+	Bevel = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_JOIN::D2D1_SVG_LINE_JOIN_MITER"]/*' />
+	/// <unmanaged>D2D1_SVG_LINE_JOIN_MITER</unmanaged>
+	Miter = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LINE_JOIN::D2D1_SVG_LINE_JOIN_ROUND"]/*' />
+	/// <unmanaged>D2D1_SVG_LINE_JOIN_ROUND</unmanaged>
+	Round = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN"]/*' />
+/// <unmanaged>D2D1_SVG_ASPECT_ALIGN</unmanaged>
+public enum SvgAspectAlign : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_NONE"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MIN"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MIN</unmanaged>
+	XMinYMin = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MIN"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MIN</unmanaged>
+	XMidYMin = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MIN"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MIN</unmanaged>
+	XMaxYMin = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MID"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MID</unmanaged>
+	XMinYMid = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MID"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MID</unmanaged>
+	XMidYMid = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MID"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MID</unmanaged>
+	XMaxYMid = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MAX"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MAX</unmanaged>
+	XMinYMax = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MAX"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MAX</unmanaged>
+	XMidYMax = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_ALIGN::D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MAX"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MAX</unmanaged>
+	XMaxYMax = 9,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_SCALING"]/*' />
+/// <unmanaged>D2D1_SVG_ASPECT_SCALING</unmanaged>
+public enum SvgAspectScaling : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_SCALING::D2D1_SVG_ASPECT_SCALING_MEET"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_SCALING_MEET</unmanaged>
+	Meet = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ASPECT_SCALING::D2D1_SVG_ASPECT_SCALING_SLICE"]/*' />
+	/// <unmanaged>D2D1_SVG_ASPECT_SCALING_SLICE</unmanaged>
+	Slice = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND"]/*' />
+/// <unmanaged>D2D1_SVG_PATH_COMMAND</unmanaged>
+public enum SvgPathCommand : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_CLOSE_PATH"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_CLOSE_PATH</unmanaged>
+	ClosePath = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_MOVE_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_MOVE_ABSOLUTE</unmanaged>
+	MoveAbsolute = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_MOVE_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_MOVE_RELATIVE</unmanaged>
+	MoveRelative = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_LINE_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_LINE_ABSOLUTE</unmanaged>
+	LineAbsolute = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_LINE_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_LINE_RELATIVE</unmanaged>
+	LineRelative = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_CUBIC_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_CUBIC_ABSOLUTE</unmanaged>
+	CubicAbsolute = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_CUBIC_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_CUBIC_RELATIVE</unmanaged>
+	CubicRelative = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_QUADRADIC_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_QUADRADIC_ABSOLUTE</unmanaged>
+	QuadradicAbsolute = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_QUADRADIC_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_QUADRADIC_RELATIVE</unmanaged>
+	QuadradicRelative = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_ARC_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_ARC_ABSOLUTE</unmanaged>
+	ArcAbsolute = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_ARC_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_ARC_RELATIVE</unmanaged>
+	ArcRelative = 10,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_HORIZONTAL_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_HORIZONTAL_ABSOLUTE</unmanaged>
+	HorizontalAbsolute = 11,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_HORIZONTAL_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_HORIZONTAL_RELATIVE</unmanaged>
+	HorizontalRelative = 12,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_VERTICAL_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_VERTICAL_ABSOLUTE</unmanaged>
+	VerticalAbsolute = 13,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_VERTICAL_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_VERTICAL_RELATIVE</unmanaged>
+	VerticalRelative = 14,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_ABSOLUTE</unmanaged>
+	CubicSmoothAbsolute = 15,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_RELATIVE</unmanaged>
+	CubicSmoothRelative = 16,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_ABSOLUTE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_ABSOLUTE</unmanaged>
+	QuadradicSmoothAbsolute = 17,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PATH_COMMAND::D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_RELATIVE"]/*' />
+	/// <unmanaged>D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_RELATIVE</unmanaged>
+	QuadradicSmoothRelative = 18,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_UNIT_TYPE"]/*' />
+/// <unmanaged>D2D1_SVG_UNIT_TYPE</unmanaged>
+public enum SvgUnitType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_UNIT_TYPE::D2D1_SVG_UNIT_TYPE_USER_SPACE_ON_USE"]/*' />
+	/// <unmanaged>D2D1_SVG_UNIT_TYPE_USER_SPACE_ON_USE</unmanaged>
+	UserSpaceOnUse = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_UNIT_TYPE::D2D1_SVG_UNIT_TYPE_OBJECT_BOUNDING_BOX"]/*' />
+	/// <unmanaged>D2D1_SVG_UNIT_TYPE_OBJECT_BOUNDING_BOX</unmanaged>
+	ObjectBoundingBox = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_STRING_TYPE"]/*' />
+/// <unmanaged>D2D1_SVG_ATTRIBUTE_STRING_TYPE</unmanaged>
+public enum SvgAttributeStringType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_STRING_TYPE::D2D1_SVG_ATTRIBUTE_STRING_TYPE_SVG"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_STRING_TYPE_SVG</unmanaged>
+	Svg = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_STRING_TYPE::D2D1_SVG_ATTRIBUTE_STRING_TYPE_ID"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_STRING_TYPE_ID</unmanaged>
+	Id = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE"]/*' />
+/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE</unmanaged>
+public enum SvgAttributePodType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_FLOAT"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_FLOAT</unmanaged>
+	Float = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_COLOR"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_COLOR</unmanaged>
+	Color = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_FILL_MODE"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_FILL_MODE</unmanaged>
+	FillMode = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_DISPLAY"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_DISPLAY</unmanaged>
+	Display = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_OVERFLOW"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_OVERFLOW</unmanaged>
+	Overflow = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_CAP"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_CAP</unmanaged>
+	LineCap = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_JOIN"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_JOIN</unmanaged>
+	LineJoin = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_VISIBILITY"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_VISIBILITY</unmanaged>
+	Visibility = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_MATRIX"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_MATRIX</unmanaged>
+	Matrix = 8,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_UNIT_TYPE"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_UNIT_TYPE</unmanaged>
+	UnitType = 9,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_EXTEND_MODE"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_EXTEND_MODE</unmanaged>
+	ExtendMode = 10,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_PRESERVE_ASPECT_RATIO"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_PRESERVE_ASPECT_RATIO</unmanaged>
+	PreserveAspectRatio = 11,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_VIEWBOX"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_VIEWBOX</unmanaged>
+	Viewbox = 12,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_ATTRIBUTE_POD_TYPE::D2D1_SVG_ATTRIBUTE_POD_TYPE_LENGTH"]/*' />
+	/// <unmanaged>D2D1_SVG_ATTRIBUTE_POD_TYPE_LENGTH</unmanaged>
+	Length = 13,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_NIB_SHAPE"]/*' />
+/// <unmanaged>D2D1_INK_NIB_SHAPE</unmanaged>
+public enum InkNibShape : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_NIB_SHAPE::D2D1_INK_NIB_SHAPE_ROUND"]/*' />
+	/// <unmanaged>D2D1_INK_NIB_SHAPE_ROUND</unmanaged>
+	Round = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_NIB_SHAPE::D2D1_INK_NIB_SHAPE_SQUARE"]/*' />
+	/// <unmanaged>D2D1_INK_NIB_SHAPE_SQUARE</unmanaged>
+	Square = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION"]/*' />
+/// <unmanaged>D2D1_ORIENTATION</unmanaged>
+public enum Orientation : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_DEFAULT</unmanaged>
+	Default = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_FLIP_HORIZONTAL</unmanaged>
+	FlipHorizontal = 2,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_ROTATE_CLOCKWISE180"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_ROTATE_CLOCKWISE180</unmanaged>
+	RotateClockwise180 = 3,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL</unmanaged>
+	RotateClockwise180FlipHorizontal = 4,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL</unmanaged>
+	RotateClockwise90FlipHorizontal = 5,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_ROTATE_CLOCKWISE270"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_ROTATE_CLOCKWISE270</unmanaged>
+	RotateClockwise270 = 6,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL</unmanaged>
+	RotateClockwise270FlipHorizontal = 7,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ORIENTATION::D2D1_ORIENTATION_ROTATE_CLOCKWISE90"]/*' />
+	/// <unmanaged>D2D1_ORIENTATION_ROTATE_CLOCKWISE90</unmanaged>
+	RotateClockwise90 = 8,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_LOADING_OPTIONS"]/*' />
+/// <unmanaged>D2D1_IMAGE_SOURCE_LOADING_OPTIONS</unmanaged>
+[Flags]
+public enum ImageSourceLoadingOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_LOADING_OPTIONS::D2D1_IMAGE_SOURCE_LOADING_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_IMAGE_SOURCE_LOADING_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_LOADING_OPTIONS::D2D1_IMAGE_SOURCE_LOADING_OPTIONS_RELEASE_SOURCE"]/*' />
+	/// <unmanaged>D2D1_IMAGE_SOURCE_LOADING_OPTIONS_RELEASE_SOURCE</unmanaged>
+	ReleaseSource = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_LOADING_OPTIONS::D2D1_IMAGE_SOURCE_LOADING_OPTIONS_CACHE_ON_DEMAND"]/*' />
+	/// <unmanaged>D2D1_IMAGE_SOURCE_LOADING_OPTIONS_CACHE_ON_DEMAND</unmanaged>
+	CacheOnDemand = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS"]/*' />
+/// <unmanaged>D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS</unmanaged>
+[Flags]
+public enum ImageSourceFromDxgiOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS::D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS::D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_LOW_QUALITY_PRIMARY_CONVERSION"]/*' />
+	/// <unmanaged>D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_LOW_QUALITY_PRIMARY_CONVERSION</unmanaged>
+	LowQualityPrimaryConversion = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS"]/*' />
+/// <unmanaged>D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS</unmanaged>
+[Flags]
+public enum TransformedImageSourceOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS::D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS::D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_DISABLE_DPI_SCALE"]/*' />
+	/// <unmanaged>D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_DISABLE_DPI_SCALE</unmanaged>
+	DisableDpiScale = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PATCH_EDGE_MODE"]/*' />
+/// <unmanaged>D2D1_PATCH_EDGE_MODE</unmanaged>
+public enum PatchEdgeMode : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PATCH_EDGE_MODE::D2D1_PATCH_EDGE_MODE_ALIASED"]/*' />
+	/// <unmanaged>D2D1_PATCH_EDGE_MODE_ALIASED</unmanaged>
+	Aliased = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PATCH_EDGE_MODE::D2D1_PATCH_EDGE_MODE_ANTIALIASED"]/*' />
+	/// <unmanaged>D2D1_PATCH_EDGE_MODE_ANTIALIASED</unmanaged>
+	Antialiased = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PATCH_EDGE_MODE::D2D1_PATCH_EDGE_MODE_ALIASED_INFLATED"]/*' />
+	/// <unmanaged>D2D1_PATCH_EDGE_MODE_ALIASED_INFLATED</unmanaged>
+	AliasedInflated = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPRITE_OPTIONS"]/*' />
+/// <unmanaged>D2D1_SPRITE_OPTIONS</unmanaged>
+[Flags]
+public enum SpriteOptions : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPRITE_OPTIONS::D2D1_SPRITE_OPTIONS_NONE"]/*' />
+	/// <unmanaged>D2D1_SPRITE_OPTIONS_NONE</unmanaged>
+	None = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SPRITE_OPTIONS::D2D1_SPRITE_OPTIONS_CLAMP_TO_SOURCE_RECTANGLE"]/*' />
+	/// <unmanaged>D2D1_SPRITE_OPTIONS_CLAMP_TO_SOURCE_RECTANGLE</unmanaged>
+	ClampToSourceRectangle = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION"]/*' />
+/// <unmanaged>D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION</unmanaged>
+public enum ColorBitmapGlyphSnapOption : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION::D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DEFAULT"]/*' />
+	/// <unmanaged>D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DEFAULT</unmanaged>
+	Default = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION::D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DISABLE"]/*' />
+	/// <unmanaged>D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DISABLE</unmanaged>
+	Disable = 1,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA1"]/*' />
+/// <unmanaged>D2D1_GAMMA1</unmanaged>
+public enum Gamma1 : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA1::D2D1_GAMMA1_G22"]/*' />
+	/// <unmanaged>D2D1_GAMMA1_G22</unmanaged>
+	G22 = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA1::D2D1_GAMMA1_G10"]/*' />
+	/// <unmanaged>D2D1_GAMMA1_G10</unmanaged>
+	G10 = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GAMMA1::D2D1_GAMMA1_G2084"]/*' />
+	/// <unmanaged>D2D1_GAMMA1_G2084</unmanaged>
+	G2084 = 2,
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_CONTEXT_TYPE"]/*' />
+/// <unmanaged>D2D1_COLOR_CONTEXT_TYPE</unmanaged>
+public enum ColorContextType : uint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_CONTEXT_TYPE::D2D1_COLOR_CONTEXT_TYPE_ICC"]/*' />
+	/// <unmanaged>D2D1_COLOR_CONTEXT_TYPE_ICC</unmanaged>
+	Icc = 0,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_CONTEXT_TYPE::D2D1_COLOR_CONTEXT_TYPE_SIMPLE"]/*' />
+	/// <unmanaged>D2D1_COLOR_CONTEXT_TYPE_SIMPLE</unmanaged>
+	Simple = 1,
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_COLOR_CONTEXT_TYPE::D2D1_COLOR_CONTEXT_TYPE_DXGI"]/*' />
+	/// <unmanaged>D2D1_COLOR_CONTEXT_TYPE_DXGI</unmanaged>
+	DXGI = 2,
+}
+
+#endregion Enums
+
+#region Structs
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_BITMAP_PROPERTIES</unmanaged>
+public partial struct BitmapProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES::pixelFormat"]/*' />
+	public Common.PixelFormat pixelFormat;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES::dpiX"]/*' />
+	public float dpiX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES::dpiY"]/*' />
+	public float dpiY;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_STOP"]/*' />
+/// <unmanaged>D2D1_GRADIENT_STOP</unmanaged>
+public partial struct GradientStop
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_STOP::position"]/*' />
+	public float position;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_STOP::color"]/*' />
+	public Common.ColorF color;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BRUSH_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_BRUSH_PROPERTIES</unmanaged>
+public partial struct BrushProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BRUSH_PROPERTIES::opacity"]/*' />
+	public float opacity;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BRUSH_PROPERTIES::transform"]/*' />
+	public Matrix3x2 transform;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_BITMAP_BRUSH_PROPERTIES</unmanaged>
+public partial struct BitmapBrushProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES::extendModeX"]/*' />
+	public ExtendMode extendModeX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES::extendModeY"]/*' />
+	public ExtendMode extendModeY;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES::interpolationMode"]/*' />
+	public BitmapInterpolationMode interpolationMode;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES</unmanaged>
+public partial struct LinearGradientBrushProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES::startPoint"]/*' />
+	public System.Drawing.PointF startPoint;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES::endPoint"]/*' />
+	public System.Drawing.PointF endPoint;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES</unmanaged>
+public partial struct RadialGradientBrushProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES::center"]/*' />
+	public System.Drawing.PointF center;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES::gradientOriginOffset"]/*' />
+	public System.Drawing.PointF gradientOriginOffset;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES::radiusX"]/*' />
+	public float radiusX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES::radiusY"]/*' />
+	public float radiusY;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRIANGLE"]/*' />
+/// <unmanaged>D2D1_TRIANGLE</unmanaged>
+public partial struct Triangle
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRIANGLE::point1"]/*' />
+	public System.Drawing.PointF point1;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRIANGLE::point2"]/*' />
+	public System.Drawing.PointF point2;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRIANGLE::point3"]/*' />
+	public System.Drawing.PointF point3;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SEGMENT"]/*' />
+/// <unmanaged>D2D1_ARC_SEGMENT</unmanaged>
+public partial struct ArcSegment
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SEGMENT::point"]/*' />
+	public System.Drawing.PointF point;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SEGMENT::size"]/*' />
+	public System.Drawing.SizeF size;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SEGMENT::rotationAngle"]/*' />
+	public float rotationAngle;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SEGMENT::sweepDirection"]/*' />
+	public SweepDirection sweepDirection;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ARC_SEGMENT::arcSize"]/*' />
+	public ArcSize arcSize;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_QUADRATIC_BEZIER_SEGMENT"]/*' />
+/// <unmanaged>D2D1_QUADRATIC_BEZIER_SEGMENT</unmanaged>
+public partial struct QuadraticBezierSegment
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_QUADRATIC_BEZIER_SEGMENT::point1"]/*' />
+	public System.Drawing.PointF point1;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_QUADRATIC_BEZIER_SEGMENT::point2"]/*' />
+	public System.Drawing.PointF point2;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ELLIPSE"]/*' />
+/// <unmanaged>D2D1_ELLIPSE</unmanaged>
+public partial struct Ellipse
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ELLIPSE::point"]/*' />
+	public System.Drawing.PointF point;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ELLIPSE::radiusX"]/*' />
+	public float radiusX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ELLIPSE::radiusY"]/*' />
+	public float radiusY;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ROUNDED_RECT"]/*' />
+/// <unmanaged>D2D1_ROUNDED_RECT</unmanaged>
+public partial struct RoundedRect
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ROUNDED_RECT::rect"]/*' />
+	public Common.RectF rect;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ROUNDED_RECT::radiusX"]/*' />
+	public float radiusX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_ROUNDED_RECT::radiusY"]/*' />
+	public float radiusY;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_STROKE_STYLE_PROPERTIES</unmanaged>
+public partial struct StrokeStyleProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::startCap"]/*' />
+	public CapStyle startCap;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::endCap"]/*' />
+	public CapStyle endCap;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::dashCap"]/*' />
+	public CapStyle dashCap;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::lineJoin"]/*' />
+	public LineJoin lineJoin;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::miterLimit"]/*' />
+	public float miterLimit;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::dashStyle"]/*' />
+	public DashStyle dashStyle;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES::dashOffset"]/*' />
+	public float dashOffset;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS"]/*' />
+/// <unmanaged>D2D1_LAYER_PARAMETERS</unmanaged>
+public partial struct LayerParameters
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::contentBounds"]/*' />
+	public Common.RectF contentBounds;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::geometricMask"]/*' />
+	public unsafe ID2D1Geometry* geometricMask;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::maskAntialiasMode"]/*' />
+	public AntialiasMode maskAntialiasMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::maskTransform"]/*' />
+	public Matrix3x2 maskTransform;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::opacity"]/*' />
+	public float opacity;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::opacityBrush"]/*' />
+	public unsafe ID2D1Brush* opacityBrush;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS::layerOptions"]/*' />
+	public LayerOptions layerOptions;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_RENDER_TARGET_PROPERTIES</unmanaged>
+public partial struct RenderTargetProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES::type"]/*' />
+	public RenderTargetType type;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES::pixelFormat"]/*' />
+	public Common.PixelFormat pixelFormat;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES::dpiX"]/*' />
+	public float dpiX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES::dpiY"]/*' />
+	public float dpiY;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES::usage"]/*' />
+	public RenderTargetUsage usage;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDER_TARGET_PROPERTIES::minLevel"]/*' />
+	public FeatureLevel minLevel;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HWND_RENDER_TARGET_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_HWND_RENDER_TARGET_PROPERTIES</unmanaged>
+public partial struct HwndRenderTargetProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HWND_RENDER_TARGET_PROPERTIES::hwnd"]/*' />
+	public IntPtr hwnd;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HWND_RENDER_TARGET_PROPERTIES::pixelSize"]/*' />
+	public Common.SizeU pixelSize;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_HWND_RENDER_TARGET_PROPERTIES::presentOptions"]/*' />
+	public PresentOptions presentOptions;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION"]/*' />
+/// <unmanaged>D2D1_DRAWING_STATE_DESCRIPTION</unmanaged>
+public partial struct DrawingStateDescription
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION::antialiasMode"]/*' />
+	public AntialiasMode antialiasMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION::textAntialiasMode"]/*' />
+	public TextAntialiasMode textAntialiasMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION::tag1"]/*' />
+	public ulong tag1;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION::tag2"]/*' />
+	public ulong tag2;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION::transform"]/*' />
+	public Matrix3x2 transform;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FACTORY_OPTIONS"]/*' />
+/// <unmanaged>D2D1_FACTORY_OPTIONS</unmanaged>
+public partial struct FactoryOptions
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FACTORY_OPTIONS::debugLevel"]/*' />
+	public DebugLevel debugLevel;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES1"]/*' />
+/// <unmanaged>D2D1_BITMAP_PROPERTIES1</unmanaged>
+public partial struct BitmapProperties1
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES1::pixelFormat"]/*' />
+	public Common.PixelFormat pixelFormat;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES1::dpiX"]/*' />
+	public float dpiX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES1::dpiY"]/*' />
+	public float dpiY;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES1::bitmapOptions"]/*' />
+	public BitmapOptions bitmapOptions;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_PROPERTIES1::colorContext"]/*' />
+	public unsafe ID2D1ColorContext* colorContext;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAPPED_RECT"]/*' />
+/// <unmanaged>D2D1_MAPPED_RECT</unmanaged>
+public partial struct MappedRect
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAPPED_RECT::pitch"]/*' />
+	public uint pitch;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_MAPPED_RECT::bits"]/*' />
+	public unsafe byte* bits;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDERING_CONTROLS"]/*' />
+/// <unmanaged>D2D1_RENDERING_CONTROLS</unmanaged>
+public partial struct RenderingControls
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDERING_CONTROLS::bufferPrecision"]/*' />
+	public BufferPrecision bufferPrecision;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RENDERING_CONTROLS::tileSize"]/*' />
+	public Common.SizeU tileSize;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EFFECT_INPUT_DESCRIPTION"]/*' />
+/// <unmanaged>D2D1_EFFECT_INPUT_DESCRIPTION</unmanaged>
+public partial struct EffectInputDescription
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EFFECT_INPUT_DESCRIPTION::effect"]/*' />
+	public unsafe ID2D1Effect* effect;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EFFECT_INPUT_DESCRIPTION::inputIndex"]/*' />
+	public uint inputIndex;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_EFFECT_INPUT_DESCRIPTION::inputRectangle"]/*' />
+	public Common.RectF inputRectangle;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINT_DESCRIPTION"]/*' />
+/// <unmanaged>D2D1_POINT_DESCRIPTION</unmanaged>
+public partial struct PointDescription
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINT_DESCRIPTION::point"]/*' />
+	public System.Drawing.PointF point;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINT_DESCRIPTION::unitTangentVector"]/*' />
+	public System.Drawing.PointF unitTangentVector;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINT_DESCRIPTION::endSegment"]/*' />
+	public uint endSegment;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINT_DESCRIPTION::endFigure"]/*' />
+	public uint endFigure;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_POINT_DESCRIPTION::lengthToEndSegment"]/*' />
+	public float lengthToEndSegment;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_BRUSH_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_IMAGE_BRUSH_PROPERTIES</unmanaged>
+public partial struct ImageBrushProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_BRUSH_PROPERTIES::sourceRectangle"]/*' />
+	public Common.RectF sourceRectangle;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_BRUSH_PROPERTIES::extendModeX"]/*' />
+	public ExtendMode extendModeX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_BRUSH_PROPERTIES::extendModeY"]/*' />
+	public ExtendMode extendModeY;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_IMAGE_BRUSH_PROPERTIES::interpolationMode"]/*' />
+	public InterpolationMode interpolationMode;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES1"]/*' />
+/// <unmanaged>D2D1_BITMAP_BRUSH_PROPERTIES1</unmanaged>
+public partial struct BitmapBrushProperties1
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES1::extendModeX"]/*' />
+	public ExtendMode extendModeX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES1::extendModeY"]/*' />
+	public ExtendMode extendModeY;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BITMAP_BRUSH_PROPERTIES1::interpolationMode"]/*' />
+	public InterpolationMode interpolationMode;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1"]/*' />
+/// <unmanaged>D2D1_STROKE_STYLE_PROPERTIES1</unmanaged>
+public partial struct StrokeStyleProperties1
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::startCap"]/*' />
+	public CapStyle startCap;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::endCap"]/*' />
+	public CapStyle endCap;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::dashCap"]/*' />
+	public CapStyle dashCap;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::lineJoin"]/*' />
+	public LineJoin lineJoin;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::miterLimit"]/*' />
+	public float miterLimit;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::dashStyle"]/*' />
+	public DashStyle dashStyle;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::dashOffset"]/*' />
+	public float dashOffset;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_STROKE_STYLE_PROPERTIES1::transformType"]/*' />
+	public StrokeTransformType transformType;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1"]/*' />
+/// <unmanaged>D2D1_LAYER_PARAMETERS1</unmanaged>
+public partial struct LayerParameters1
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::contentBounds"]/*' />
+	public Common.RectF contentBounds;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::geometricMask"]/*' />
+	public unsafe ID2D1Geometry* geometricMask;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::maskAntialiasMode"]/*' />
+	public AntialiasMode maskAntialiasMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::maskTransform"]/*' />
+	public Matrix3x2 maskTransform;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::opacity"]/*' />
+	public float opacity;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::opacityBrush"]/*' />
+	public unsafe ID2D1Brush* opacityBrush;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_LAYER_PARAMETERS1::layerOptions"]/*' />
+	public LayerOptions1 layerOptions;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1"]/*' />
+/// <unmanaged>D2D1_DRAWING_STATE_DESCRIPTION1</unmanaged>
+public partial struct DrawingStateDescription1
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::antialiasMode"]/*' />
+	public AntialiasMode antialiasMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::textAntialiasMode"]/*' />
+	public TextAntialiasMode textAntialiasMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::tag1"]/*' />
+	public ulong tag1;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::tag2"]/*' />
+	public ulong tag2;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::transform"]/*' />
+	public Matrix3x2 transform;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::primitiveBlend"]/*' />
+	public PrimitiveBlend primitiveBlend;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_DRAWING_STATE_DESCRIPTION1::unitMode"]/*' />
+	public UnitMode unitMode;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_CONTROL_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_PRINT_CONTROL_PROPERTIES</unmanaged>
+public partial struct PrintControlProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_CONTROL_PROPERTIES::fontSubset"]/*' />
+	public PrintFontSubsetMode fontSubset;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_CONTROL_PROPERTIES::rasterDPI"]/*' />
+	public float rasterDPI;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PRINT_CONTROL_PROPERTIES::colorSpace"]/*' />
+	public ColorSpace colorSpace;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CREATION_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_CREATION_PROPERTIES</unmanaged>
+public partial struct CreationProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CREATION_PROPERTIES::threadingMode"]/*' />
+	public ThreadingMode threadingMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CREATION_PROPERTIES::debugLevel"]/*' />
+	public DebugLevel debugLevel;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CREATION_PROPERTIES::options"]/*' />
+	public DeviceContextOptions options;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_BINDING"]/*' />
+/// <unmanaged>D2D1_PROPERTY_BINDING</unmanaged>
+public partial struct PropertyBinding
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_BINDING::propertyName"]/*' />
+	public unsafe ushort* propertyName;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_BINDING::setFunction"]/*' />
+	public unsafe delegate* unmanaged[Stdcall]<IUnknown*, byte*, uint, HResult> setFunction;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_PROPERTY_BINDING::getFunction"]/*' />
+	public unsafe delegate* unmanaged[Stdcall]<IUnknown*, byte*, uint, uint*, HResult> getFunction;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_RESOURCE_TEXTURE_PROPERTIES</unmanaged>
+public partial struct ResourceTextureProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES::extents"]/*' />
+	public unsafe uint* extents;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES::dimensions"]/*' />
+	public uint dimensions;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES::bufferPrecision"]/*' />
+	public BufferPrecision bufferPrecision;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES::channelDepth"]/*' />
+	public ChannelDepth channelDepth;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES::filter"]/*' />
+	public Filter filter;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_RESOURCE_TEXTURE_PROPERTIES::extendModes"]/*' />
+	public unsafe ExtendMode* extendModes;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_ELEMENT_DESC"]/*' />
+/// <unmanaged>D2D1_INPUT_ELEMENT_DESC</unmanaged>
+public partial struct InputElementDescription
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_ELEMENT_DESC::semanticName"]/*' />
+	public unsafe sbyte* semanticName;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_ELEMENT_DESC::semanticIndex"]/*' />
+	public uint semanticIndex;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_ELEMENT_DESC::format"]/*' />
+	public Graphics.Dxgi.Common.Format format;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_ELEMENT_DESC::inputSlot"]/*' />
+	public uint inputSlot;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_ELEMENT_DESC::alignedByteOffset"]/*' />
+	public uint alignedByteOffset;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_BUFFER_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_VERTEX_BUFFER_PROPERTIES</unmanaged>
+public partial struct VertexBufferProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_BUFFER_PROPERTIES::inputCount"]/*' />
+	public uint inputCount;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_BUFFER_PROPERTIES::usage"]/*' />
+	public VertexUsage usage;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_BUFFER_PROPERTIES::data"]/*' />
+	public unsafe byte* data;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_BUFFER_PROPERTIES::byteWidth"]/*' />
+	public uint byteWidth;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES</unmanaged>
+public partial struct CustomVertexBufferProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES::shaderBufferWithInputSignature"]/*' />
+	public unsafe byte* shaderBufferWithInputSignature;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES::shaderBufferSize"]/*' />
+	public uint shaderBufferSize;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES::inputElements"]/*' />
+	public unsafe InputElementDescription* inputElements;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES::elementCount"]/*' />
+	public uint elementCount;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES::stride"]/*' />
+	public uint stride;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_RANGE"]/*' />
+/// <unmanaged>D2D1_VERTEX_RANGE</unmanaged>
+public partial struct VertexRange
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_RANGE::startVertex"]/*' />
+	public uint startVertex;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_VERTEX_RANGE::vertexCount"]/*' />
+	public uint vertexCount;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION"]/*' />
+/// <unmanaged>D2D1_BLEND_DESCRIPTION</unmanaged>
+public partial struct BlendDescription
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::sourceBlend"]/*' />
+	public Blend sourceBlend;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::destinationBlend"]/*' />
+	public Blend destinationBlend;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::blendOperation"]/*' />
+	public BlendOperation blendOperation;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::sourceBlendAlpha"]/*' />
+	public Blend sourceBlendAlpha;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::destinationBlendAlpha"]/*' />
+	public Blend destinationBlendAlpha;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::blendOperationAlpha"]/*' />
+	public BlendOperation blendOperationAlpha;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_BLEND_DESCRIPTION::blendFactor"]/*' />
+	public unsafe fixed float blendFactor[4];
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_DESCRIPTION"]/*' />
+/// <unmanaged>D2D1_INPUT_DESCRIPTION</unmanaged>
+public partial struct InputDescription
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_DESCRIPTION::filter"]/*' />
+	public Filter filter;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INPUT_DESCRIPTION::levelOfDetailCount"]/*' />
+	public uint levelOfDetailCount;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_DATA_DOUBLES"]/*' />
+/// <unmanaged>D2D1_FEATURE_DATA_DOUBLES</unmanaged>
+public partial struct FeatureDataDoubles
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_DATA_DOUBLES::doublePrecisionFloatShaderOps"]/*' />
+	public Bool32 doublePrecisionFloatShaderOps;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS"]/*' />
+/// <unmanaged>D2D1_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS</unmanaged>
+public partial struct FeatureDataD3d10XHardwareOptions
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS::computeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x"]/*' />
+	public Bool32 computeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LENGTH"]/*' />
+/// <unmanaged>D2D1_SVG_LENGTH</unmanaged>
+public partial struct SvgLength
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LENGTH::value"]/*' />
+	public float value;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_LENGTH::units"]/*' />
+	public SvgLengthUnits units;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PRESERVE_ASPECT_RATIO"]/*' />
+/// <unmanaged>D2D1_SVG_PRESERVE_ASPECT_RATIO</unmanaged>
+public partial struct SvgPreserveAspectRatio
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PRESERVE_ASPECT_RATIO::defer"]/*' />
+	public Bool32 defer;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PRESERVE_ASPECT_RATIO::align"]/*' />
+	public SvgAspectAlign align;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_PRESERVE_ASPECT_RATIO::meetOrSlice"]/*' />
+	public SvgAspectScaling meetOrSlice;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VIEWBOX"]/*' />
+/// <unmanaged>D2D1_SVG_VIEWBOX</unmanaged>
+public partial struct SvgViewbox
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VIEWBOX::x"]/*' />
+	public float x;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VIEWBOX::y"]/*' />
+	public float y;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VIEWBOX::width"]/*' />
+	public float width;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SVG_VIEWBOX::height"]/*' />
+	public float height;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES</unmanaged>
+public partial struct TransformedImageSourceProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES::orientation"]/*' />
+	public Orientation orientation;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES::scaleX"]/*' />
+	public float scaleX;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES::scaleY"]/*' />
+	public float scaleY;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES::interpolationMode"]/*' />
+	public InterpolationMode interpolationMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES::options"]/*' />
+	public TransformedImageSourceOptions options;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_POINT"]/*' />
+/// <unmanaged>D2D1_INK_POINT</unmanaged>
+public partial struct InkPoint
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_POINT::x"]/*' />
+	public float x;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_POINT::y"]/*' />
+	public float y;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_POINT::radius"]/*' />
+	public float radius;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_BEZIER_SEGMENT"]/*' />
+/// <unmanaged>D2D1_INK_BEZIER_SEGMENT</unmanaged>
+public partial struct InkBezierSegment
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_BEZIER_SEGMENT::point1"]/*' />
+	public InkPoint point1;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_BEZIER_SEGMENT::point2"]/*' />
+	public InkPoint point2;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_BEZIER_SEGMENT::point3"]/*' />
+	public InkPoint point3;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_STYLE_PROPERTIES"]/*' />
+/// <unmanaged>D2D1_INK_STYLE_PROPERTIES</unmanaged>
+public partial struct InkStyleProperties
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_STYLE_PROPERTIES::nibShape"]/*' />
+	public InkNibShape nibShape;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_INK_STYLE_PROPERTIES::nibTransform"]/*' />
+	public Matrix3x2 nibTransform;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH"]/*' />
+/// <unmanaged>D2D1_GRADIENT_MESH_PATCH</unmanaged>
+public partial struct GradientMeshPatch
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point00"]/*' />
+	public System.Drawing.PointF point00;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point01"]/*' />
+	public System.Drawing.PointF point01;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point02"]/*' />
+	public System.Drawing.PointF point02;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point03"]/*' />
+	public System.Drawing.PointF point03;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point10"]/*' />
+	public System.Drawing.PointF point10;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point11"]/*' />
+	public System.Drawing.PointF point11;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point12"]/*' />
+	public System.Drawing.PointF point12;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point13"]/*' />
+	public System.Drawing.PointF point13;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point20"]/*' />
+	public System.Drawing.PointF point20;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point21"]/*' />
+	public System.Drawing.PointF point21;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point22"]/*' />
+	public System.Drawing.PointF point22;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point23"]/*' />
+	public System.Drawing.PointF point23;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point30"]/*' />
+	public System.Drawing.PointF point30;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point31"]/*' />
+	public System.Drawing.PointF point31;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point32"]/*' />
+	public System.Drawing.PointF point32;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::point33"]/*' />
+	public System.Drawing.PointF point33;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::color00"]/*' />
+	public Common.ColorF color00;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::color03"]/*' />
+	public Common.ColorF color03;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::color30"]/*' />
+	public Common.ColorF color30;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::color33"]/*' />
+	public Common.ColorF color33;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::topEdgeMode"]/*' />
+	public PatchEdgeMode topEdgeMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::leftEdgeMode"]/*' />
+	public PatchEdgeMode leftEdgeMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::bottomEdgeMode"]/*' />
+	public PatchEdgeMode bottomEdgeMode;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_GRADIENT_MESH_PATCH::rightEdgeMode"]/*' />
+	public PatchEdgeMode rightEdgeMode;
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SIMPLE_COLOR_PROFILE"]/*' />
+/// <unmanaged>D2D1_SIMPLE_COLOR_PROFILE</unmanaged>
+public partial struct SimpleColorProfile
+{
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SIMPLE_COLOR_PROFILE::redPrimary"]/*' />
+	public System.Drawing.PointF redPrimary;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SIMPLE_COLOR_PROFILE::greenPrimary"]/*' />
+	public System.Drawing.PointF greenPrimary;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SIMPLE_COLOR_PROFILE::bluePrimary"]/*' />
+	public System.Drawing.PointF bluePrimary;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SIMPLE_COLOR_PROFILE::whitePointXZ"]/*' />
+	public System.Drawing.PointF whitePointXZ;
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="D2D1_SIMPLE_COLOR_PROFILE::gamma"]/*' />
+	public Gamma1 gamma;
+}
+
+#endregion Structs
+
+#region COM Types
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Resource"]/*' />
+/// <unmanaged>ID2D1Resource</unmanaged>
+[Guid("2cd90691-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1Resource : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1Resource
+{
+	public static ref readonly Guid IID_ID2D1Resource
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x91, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1Resource));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Resource::GetFactory"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Resource*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Resource*)Unsafe.AsPointer(ref this), factory);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Image"]/*' />
+/// <unmanaged>ID2D1Image</unmanaged>
+[Guid("65019f75-8da2-497c-b32c-dfa34e48ede6")]
+[NativeTypeName("struct ID2D1Image : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Image
+{
+	public static ref readonly Guid IID_ID2D1Image
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x75, 0x9F, 0x01, 0x65,
+				0xA2, 0x8D,
+				0x7C, 0x49,
+				0xB3,
+				0x2C,
+				0xDF,
+				0xA3,
+				0x4E,
+				0x48,
+				0xED,
+				0xE6
+			};
+
+			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_ID2D1Image));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Image*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Image*)Unsafe.AsPointer(ref this), factory);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap"]/*' />
+/// <unmanaged>ID2D1Bitmap</unmanaged>
+[Guid("a2296057-ea42-4099-983b-539fb6505426")]
+[NativeTypeName("struct ID2D1Bitmap : ID2D1Image")]
+[NativeInheritance("ID2D1Image")]
+public unsafe partial struct ID2D1Bitmap
+{
+	public static ref readonly Guid IID_ID2D1Bitmap
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x57, 0x60, 0x29, 0xA2,
+				0x42, 0xEA,
+				0x99, 0x40,
+				0x98,
+				0x3B,
+				0x53,
+				0x9F,
+				0xB6,
+				0x50,
+				0x54,
+				0x26
+			};
+
+			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_ID2D1Bitmap));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::GetSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, System.Drawing.SizeF>)(lpVtbl[4]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::GetPixelSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[5]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::GetPixelFormat"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[6]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::GetDpi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, float*, float*, void>)(lpVtbl[7]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::CopyFromBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CopyFromBitmap(Common.Point2u* destPoint, ID2D1Bitmap* bitmap, Common.RectU* srcRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, Common.Point2u*, ID2D1Bitmap*, Common.RectU*, int>)(lpVtbl[8]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this), destPoint, bitmap, srcRect);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::CopyFromRenderTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CopyFromRenderTarget(Common.Point2u* destPoint, ID2D1RenderTarget* renderTarget, Common.RectU* srcRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, Common.Point2u*, ID2D1RenderTarget*, Common.RectU*, int>)(lpVtbl[9]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this), destPoint, renderTarget, srcRect);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::CopyFromMemory"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CopyFromMemory(Common.RectU* dstRect, void* srcData, uint pitch)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, Common.RectU*, void*, uint, int>)(lpVtbl[10]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this), dstRect, srcData, pitch);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection"]/*' />
+/// <unmanaged>ID2D1GradientStopCollection</unmanaged>
+[Guid("2cd906a7-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1GradientStopCollection : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1GradientStopCollection
+{
+	public static ref readonly Guid IID_ID2D1GradientStopCollection
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA7, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1GradientStopCollection));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection::GetGradientStopCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public uint GetGradientStopCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, uint>)(lpVtbl[4]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection::GetGradientStops"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetGradientStops(GradientStop* gradientStops, uint gradientStopsCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, GradientStop*, uint, void>)(lpVtbl[5]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection::GetColorInterpolationGamma"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.Gamma GetColorInterpolationGamma()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, Graphics.Direct2D.Gamma>)(lpVtbl[6]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection::GetExtendMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.ExtendMode GetExtendMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, Graphics.Direct2D.ExtendMode>)(lpVtbl[7]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Brush"]/*' />
+/// <unmanaged>ID2D1Brush</unmanaged>
+[Guid("2cd906a8-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1Brush : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Brush
+{
+	public static ref readonly Guid IID_ID2D1Brush
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA8, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1Brush));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Brush*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Brush*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Brush::SetOpacity"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Brush*, float, void>)(lpVtbl[4]))((ID2D1Brush*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Brush::SetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Brush*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1Brush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Brush::GetOpacity"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Brush*, float>)(lpVtbl[6]))((ID2D1Brush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Brush::GetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Brush*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1Brush*)Unsafe.AsPointer(ref this), transform);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush"]/*' />
+/// <unmanaged>ID2D1BitmapBrush</unmanaged>
+[Guid("2cd906aa-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1BitmapBrush : ID2D1Brush")]
+[NativeInheritance("ID2D1Brush")]
+public unsafe partial struct ID2D1BitmapBrush
+{
+	public static ref readonly Guid IID_ID2D1BitmapBrush
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xAA, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1BitmapBrush));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, float, void>)(lpVtbl[3]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Matrix3x2*, void>)(lpVtbl[4]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, float>)(lpVtbl[5]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Matrix3x2**, void>)(lpVtbl[6]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::SetExtendModeX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void SetExtendModeX(ExtendMode extendModeX)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ExtendMode, void>)(lpVtbl[8]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), extendModeX);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::SetExtendModeY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void SetExtendModeY(ExtendMode extendModeY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ExtendMode, void>)(lpVtbl[9]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), extendModeY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::SetInterpolationMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void SetInterpolationMode(BitmapInterpolationMode interpolationMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, BitmapInterpolationMode, void>)(lpVtbl[10]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), interpolationMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::SetBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void SetBitmap(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ID2D1Bitmap*, void>)(lpVtbl[11]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::GetExtendModeX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeX()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Graphics.Direct2D.ExtendMode>)(lpVtbl[12]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::GetExtendModeY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeY()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Graphics.Direct2D.ExtendMode>)(lpVtbl[13]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::GetInterpolationMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public Graphics.Direct2D.BitmapInterpolationMode GetInterpolationMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Graphics.Direct2D.BitmapInterpolationMode>)(lpVtbl[14]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::GetBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void GetBitmap(ID2D1Bitmap** bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ID2D1Bitmap**, void>)(lpVtbl[15]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), bitmap);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SolidColorBrush"]/*' />
+/// <unmanaged>ID2D1SolidColorBrush</unmanaged>
+[Guid("2cd906a9-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1SolidColorBrush : ID2D1Brush")]
+[NativeInheritance("ID2D1Brush")]
+public unsafe partial struct ID2D1SolidColorBrush
+{
+	public static ref readonly Guid IID_ID2D1SolidColorBrush
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA9, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1SolidColorBrush));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, float, void>)(lpVtbl[3]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Matrix3x2*, void>)(lpVtbl[4]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, float>)(lpVtbl[5]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Matrix3x2**, void>)(lpVtbl[6]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SolidColorBrush::SetColor"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void SetColor(Common.ColorF* color)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Common.ColorF*, void>)(lpVtbl[8]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SolidColorBrush::GetColor"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public Graphics.Direct2D.Common.ColorF GetColor()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Graphics.Direct2D.Common.ColorF>)(lpVtbl[9]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush"]/*' />
+/// <unmanaged>ID2D1LinearGradientBrush</unmanaged>
+[Guid("2cd906ab-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1LinearGradientBrush : ID2D1Brush")]
+[NativeInheritance("ID2D1Brush")]
+public unsafe partial struct ID2D1LinearGradientBrush
+{
+	public static ref readonly Guid IID_ID2D1LinearGradientBrush
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xAB, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1LinearGradientBrush));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, float, void>)(lpVtbl[3]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, Matrix3x2*, void>)(lpVtbl[4]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, float>)(lpVtbl[5]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, Matrix3x2**, void>)(lpVtbl[6]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush::SetStartPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void SetStartPoint(System.Drawing.PointF* startPoint)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, System.Drawing.PointF*, void>)(lpVtbl[8]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), startPoint);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush::SetEndPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void SetEndPoint(System.Drawing.PointF* endPoint)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, System.Drawing.PointF*, void>)(lpVtbl[9]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), endPoint);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush::GetStartPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public System.Drawing.PointF GetStartPoint()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, System.Drawing.PointF>)(lpVtbl[10]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush::GetEndPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public System.Drawing.PointF GetEndPoint()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, System.Drawing.PointF>)(lpVtbl[11]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush::GetGradientStopCollection"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void GetGradientStopCollection(ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, ID2D1GradientStopCollection**, void>)(lpVtbl[12]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), gradientStopCollection);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush"]/*' />
+/// <unmanaged>ID2D1RadialGradientBrush</unmanaged>
+[Guid("2cd906ac-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1RadialGradientBrush : ID2D1Brush")]
+[NativeInheritance("ID2D1Brush")]
+public unsafe partial struct ID2D1RadialGradientBrush
+{
+	public static ref readonly Guid IID_ID2D1RadialGradientBrush
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xAC, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1RadialGradientBrush));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float, void>)(lpVtbl[3]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, Matrix3x2*, void>)(lpVtbl[4]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float>)(lpVtbl[5]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, Matrix3x2**, void>)(lpVtbl[6]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::SetCenter"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void SetCenter(System.Drawing.PointF* center)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, System.Drawing.PointF*, void>)(lpVtbl[8]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), center);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::SetGradientOriginOffset"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void SetGradientOriginOffset(System.Drawing.PointF* gradientOriginOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, System.Drawing.PointF*, void>)(lpVtbl[9]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), gradientOriginOffset);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::SetRadiusX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void SetRadiusX(float radiusX)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float, void>)(lpVtbl[10]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), radiusX);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::SetRadiusY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void SetRadiusY(float radiusY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float, void>)(lpVtbl[11]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), radiusY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::GetCenter"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public System.Drawing.PointF GetCenter()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, System.Drawing.PointF>)(lpVtbl[12]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::GetGradientOriginOffset"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public System.Drawing.PointF GetGradientOriginOffset()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, System.Drawing.PointF>)(lpVtbl[13]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::GetRadiusX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public float GetRadiusX()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float>)(lpVtbl[14]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::GetRadiusY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public float GetRadiusY()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float>)(lpVtbl[15]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::GetGradientStopCollection"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetGradientStopCollection(ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, ID2D1GradientStopCollection**, void>)(lpVtbl[16]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), gradientStopCollection);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle"]/*' />
+/// <unmanaged>ID2D1StrokeStyle</unmanaged>
+[Guid("2cd9069d-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1StrokeStyle : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1StrokeStyle
+{
+	public static ref readonly Guid IID_ID2D1StrokeStyle
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x9D, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1StrokeStyle));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetStartCap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public Graphics.Direct2D.CapStyle GetStartCap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, Graphics.Direct2D.CapStyle>)(lpVtbl[4]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetEndCap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public Graphics.Direct2D.CapStyle GetEndCap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, Graphics.Direct2D.CapStyle>)(lpVtbl[5]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetDashCap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.CapStyle GetDashCap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, Graphics.Direct2D.CapStyle>)(lpVtbl[6]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetMiterLimit"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public float GetMiterLimit()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, float>)(lpVtbl[7]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetLineJoin"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public Graphics.Direct2D.LineJoin GetLineJoin()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, Graphics.Direct2D.LineJoin>)(lpVtbl[8]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetDashOffset"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public float GetDashOffset()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, float>)(lpVtbl[9]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetDashStyle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public Graphics.Direct2D.DashStyle GetDashStyle()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, Graphics.Direct2D.DashStyle>)(lpVtbl[10]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetDashesCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public uint GetDashesCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, uint>)(lpVtbl[11]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle::GetDashes"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void GetDashes(float* dashes, uint dashesCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle*, float*, uint, void>)(lpVtbl[12]))((ID2D1StrokeStyle*)Unsafe.AsPointer(ref this), dashes, dashesCount);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry"]/*' />
+/// <unmanaged>ID2D1Geometry</unmanaged>
+[Guid("2cd906a1-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1Geometry : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Geometry
+{
+	public static ref readonly Guid IID_ID2D1Geometry
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA1, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1Geometry));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Geometry*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::GetBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::GetWidenedBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::StrokeContainsPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::FillContainsPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[7]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::CompareWithGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::Simplify"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::Tessellate"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::CombineWithGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::Outline"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::ComputeArea"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::ComputeLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::ComputePointAtLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Geometry::Widen"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Geometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1Geometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RectangleGeometry"]/*' />
+/// <unmanaged>ID2D1RectangleGeometry</unmanaged>
+[Guid("2cd906a2-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1RectangleGeometry : ID2D1Geometry")]
+[NativeInheritance("ID2D1Geometry")]
+public unsafe partial struct ID2D1RectangleGeometry
+{
+	public static ref readonly Guid IID_ID2D1RectangleGeometry
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA2, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1RectangleGeometry));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[3]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[4]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[5]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[7]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[8]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[9]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[10]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[12]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[14]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, ID2D1Factory**, void>)(lpVtbl[16]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RectangleGeometry::GetRect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetRect(Common.RectF* rect)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Common.RectF*, void>)(lpVtbl[17]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), rect);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RoundedRectangleGeometry"]/*' />
+/// <unmanaged>ID2D1RoundedRectangleGeometry</unmanaged>
+[Guid("2cd906a3-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1RoundedRectangleGeometry : ID2D1Geometry")]
+[NativeInheritance("ID2D1Geometry")]
+public unsafe partial struct ID2D1RoundedRectangleGeometry
+{
+	public static ref readonly Guid IID_ID2D1RoundedRectangleGeometry
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA3, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1RoundedRectangleGeometry));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[3]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[4]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[5]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[7]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[8]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[9]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[10]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[12]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[14]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, ID2D1Factory**, void>)(lpVtbl[16]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RoundedRectangleGeometry::GetRoundedRect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetRoundedRect(RoundedRect* roundedRect)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, RoundedRect*, void>)(lpVtbl[17]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), roundedRect);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EllipseGeometry"]/*' />
+/// <unmanaged>ID2D1EllipseGeometry</unmanaged>
+[Guid("2cd906a4-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1EllipseGeometry : ID2D1Geometry")]
+[NativeInheritance("ID2D1Geometry")]
+public unsafe partial struct ID2D1EllipseGeometry
+{
+	public static ref readonly Guid IID_ID2D1EllipseGeometry
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA4, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1EllipseGeometry));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[3]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[4]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[5]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[7]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[8]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[9]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[10]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[12]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[14]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, ID2D1Factory**, void>)(lpVtbl[16]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EllipseGeometry::GetEllipse"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetEllipse(Ellipse* ellipse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Ellipse*, void>)(lpVtbl[17]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), ellipse);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometryGroup"]/*' />
+/// <unmanaged>ID2D1GeometryGroup</unmanaged>
+[Guid("2cd906a6-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1GeometryGroup : ID2D1Geometry")]
+[NativeInheritance("ID2D1Geometry")]
+public unsafe partial struct ID2D1GeometryGroup
+{
+	public static ref readonly Guid IID_ID2D1GeometryGroup
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA6, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1GeometryGroup));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[3]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[4]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[5]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[7]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[8]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[9]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[10]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, float*, int>)(lpVtbl[12]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[14]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, ID2D1Factory**, void>)(lpVtbl[16]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometryGroup::GetFillMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public Graphics.Direct2D.Common.FillMode GetFillMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Graphics.Direct2D.Common.FillMode>)(lpVtbl[17]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometryGroup::GetSourceGeometryCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public uint GetSourceGeometryCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, uint>)(lpVtbl[18]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometryGroup::GetSourceGeometries"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void GetSourceGeometries(ID2D1Geometry** geometries, uint geometriesCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, ID2D1Geometry**, uint, void>)(lpVtbl[19]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), geometries, geometriesCount);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformedGeometry"]/*' />
+/// <unmanaged>ID2D1TransformedGeometry</unmanaged>
+[Guid("2cd906bb-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1TransformedGeometry : ID2D1Geometry")]
+[NativeInheritance("ID2D1Geometry")]
+public unsafe partial struct ID2D1TransformedGeometry
+{
+	public static ref readonly Guid IID_ID2D1TransformedGeometry
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBB, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1TransformedGeometry));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[3]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[4]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[5]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[7]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[8]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[9]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[10]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[12]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[14]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, ID2D1Factory**, void>)(lpVtbl[16]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformedGeometry::GetSourceGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetSourceGeometry(ID2D1Geometry** sourceGeometry)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, ID2D1Geometry**, void>)(lpVtbl[17]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), sourceGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformedGeometry::GetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformedGeometry*, Matrix3x2**, void>)(lpVtbl[18]))((ID2D1TransformedGeometry*)Unsafe.AsPointer(ref this), transform);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometrySink"]/*' />
+/// <unmanaged>ID2D1GeometrySink</unmanaged>
+[Guid("2cd9069f-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1GeometrySink : ID2D1SimplifiedGeometrySink")]
+[NativeInheritance("ID2D1SimplifiedGeometrySink")]
+public unsafe partial struct ID2D1GeometrySink
+{
+	public static ref readonly Guid IID_ID2D1GeometrySink
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x9F, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1GeometrySink));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.SetFillMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public void SetFillMode(Common.FillMode fillMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, Common.FillMode, void>)(lpVtbl[0]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), fillMode);
+	}
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.SetSegmentFlags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	public void SetSegmentFlags(Common.PathSegment vertexFlags)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, Common.PathSegment, void>)(lpVtbl[1]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), vertexFlags);
+	}
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.BeginFigure" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	public void BeginFigure(System.Drawing.PointF* startPoint, Common.FigureBegin figureBegin)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, System.Drawing.PointF*, Common.FigureBegin, void>)(lpVtbl[2]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), startPoint, figureBegin);
+	}
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.AddLines" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void AddLines(System.Drawing.PointF** points, uint pointsCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, System.Drawing.PointF**, uint, void>)(lpVtbl[3]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), points, pointsCount);
+	}
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.AddBeziers" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void AddBeziers(Common.BezierSegment* beziers, uint beziersCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, Common.BezierSegment*, uint, void>)(lpVtbl[4]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), beziers, beziersCount);
+	}
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.EndFigure" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void EndFigure(Common.FigureEnd figureEnd)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, Common.FigureEnd, void>)(lpVtbl[5]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), figureEnd);
+	}
+
+	/// <inheritdoc cref="ID2D1SimplifiedGeometrySink.Close" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult Close()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, int>)(lpVtbl[6]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometrySink::AddLine"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void AddLine(System.Drawing.PointF* point)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, System.Drawing.PointF*, void>)(lpVtbl[7]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), point);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometrySink::AddBezier"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void AddBezier(Common.BezierSegment* bezier)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, Common.BezierSegment*, void>)(lpVtbl[8]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), bezier);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometrySink::AddQuadraticBezier"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void AddQuadraticBezier(QuadraticBezierSegment* bezier)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, QuadraticBezierSegment*, void>)(lpVtbl[9]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), bezier);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometrySink::AddQuadraticBeziers"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void AddQuadraticBeziers(QuadraticBezierSegment* beziers, uint beziersCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, QuadraticBezierSegment*, uint, void>)(lpVtbl[10]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), beziers, beziersCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometrySink::AddArc"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void AddArc(ArcSegment* arc)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometrySink*, ArcSegment*, void>)(lpVtbl[11]))((ID2D1GeometrySink*)Unsafe.AsPointer(ref this), arc);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TessellationSink"]/*' />
+/// <unmanaged>ID2D1TessellationSink</unmanaged>
+[Guid("2cd906c1-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1TessellationSink : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1TessellationSink
+{
+	public static ref readonly Guid IID_ID2D1TessellationSink
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC1, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1TessellationSink));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TessellationSink::AddTriangles"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void AddTriangles(Triangle* triangles, uint trianglesCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TessellationSink*, Triangle*, uint, void>)(lpVtbl[3]))((ID2D1TessellationSink*)Unsafe.AsPointer(ref this), triangles, trianglesCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TessellationSink::Close"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Close()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TessellationSink*, int>)(lpVtbl[4]))((ID2D1TessellationSink*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry"]/*' />
+/// <unmanaged>ID2D1PathGeometry</unmanaged>
+[Guid("2cd906a5-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1PathGeometry : ID2D1Geometry")]
+[NativeInheritance("ID2D1Geometry")]
+public unsafe partial struct ID2D1PathGeometry
+{
+	public static ref readonly Guid IID_ID2D1PathGeometry
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA5, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1PathGeometry));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[3]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[4]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[5]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[7]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[8]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[9]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[10]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[12]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[14]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1Factory**, void>)(lpVtbl[16]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry::Open"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult Open(ID2D1GeometrySink** geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1GeometrySink**, int>)(lpVtbl[17]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), geometrySink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry::Stream"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult Stream(ID2D1GeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1GeometrySink*, int>)(lpVtbl[18]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), geometrySink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry::GetSegmentCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult GetSegmentCount(uint* count)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, uint*, int>)(lpVtbl[19]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), count);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry::GetFigureCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult GetFigureCount(uint* count)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, uint*, int>)(lpVtbl[20]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), count);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Mesh"]/*' />
+/// <unmanaged>ID2D1Mesh</unmanaged>
+[Guid("2cd906c2-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1Mesh : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Mesh
+{
+	public static ref readonly Guid IID_ID2D1Mesh
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC2, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1Mesh));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Mesh*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Mesh*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Mesh::Open"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Open(ID2D1TessellationSink** tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Mesh*, ID2D1TessellationSink**, int>)(lpVtbl[4]))((ID2D1Mesh*)Unsafe.AsPointer(ref this), tessellationSink);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Layer"]/*' />
+/// <unmanaged>ID2D1Layer</unmanaged>
+[Guid("2cd9069b-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1Layer : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Layer
+{
+	public static ref readonly Guid IID_ID2D1Layer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x9B, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1Layer));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Layer*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Layer*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Layer::GetSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Layer*, System.Drawing.SizeF>)(lpVtbl[4]))((ID2D1Layer*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock"]/*' />
+/// <unmanaged>ID2D1DrawingStateBlock</unmanaged>
+[Guid("28506e39-ebf6-46a1-bb47-fd85565ab957")]
+[NativeTypeName("struct ID2D1DrawingStateBlock : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1DrawingStateBlock
+{
+	public static ref readonly Guid IID_ID2D1DrawingStateBlock
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x39, 0x6E, 0x50, 0x28,
+				0xF6, 0xEB,
+				0xA1, 0x46,
+				0xBB,
+				0x47,
+				0xFD,
+				0x85,
+				0x56,
+				0x5A,
+				0xB9,
+				0x57
+			};
+
+			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_ID2D1DrawingStateBlock));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DrawingStateBlock*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock::GetDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetDescription(DrawingStateDescription* stateDescription)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock*, DrawingStateDescription*, void>)(lpVtbl[4]))((ID2D1DrawingStateBlock*)Unsafe.AsPointer(ref this), stateDescription);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock::SetDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetDescription(DrawingStateDescription* stateDescription)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock*, DrawingStateDescription*, void>)(lpVtbl[5]))((ID2D1DrawingStateBlock*)Unsafe.AsPointer(ref this), stateDescription);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock::SetTextRenderingParams"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[6]))((ID2D1DrawingStateBlock*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock::GetTextRenderingParams"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[7]))((ID2D1DrawingStateBlock*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget"]/*' />
+/// <unmanaged>ID2D1RenderTarget</unmanaged>
+[Guid("2cd90694-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1RenderTarget : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1RenderTarget
+{
+	public static ref readonly Guid IID_ID2D1RenderTarget
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x94, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1RenderTarget));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateBitmapFromWicBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateSharedBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateBitmapBrush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateSolidColorBrush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateGradientStopCollection"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[9]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateLinearGradientBrush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateRadialGradientBrush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateCompatibleRenderTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateLayer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::CreateMesh"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawLine"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::FillRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawRoundedRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::FillRoundedRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawEllipse"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::FillEllipse"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::FillGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::FillMesh"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::FillOpacityMask"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawText"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawTextLayout"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::DrawGlyphRun"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SetAntialiasMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetAntialiasMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[33]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SetTextAntialiasMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetTextAntialiasMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[35]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SetTextRenderingParams"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetTextRenderingParams"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SetTags"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetTags"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::PushLayer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::PopLayer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, void>)(lpVtbl[41]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::Flush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SaveDrawingState"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::RestoreDrawingState"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::PushAxisAlignedClip"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::PopAxisAlignedClip"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, void>)(lpVtbl[46]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::Clear"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::BeginDraw"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, void>)(lpVtbl[48]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::EndDraw"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetPixelFormat"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[50]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::SetDpi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, float, float, void>)(lpVtbl[51]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetDpi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, float*, float*, void>)(lpVtbl[52]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetPixelSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[54]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::GetMaximumBitmapSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, uint>)(lpVtbl[55]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderTarget::IsSupported"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapRenderTarget"]/*' />
+/// <unmanaged>ID2D1BitmapRenderTarget</unmanaged>
+[Guid("2cd90695-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1BitmapRenderTarget : ID2D1RenderTarget")]
+[NativeInheritance("ID2D1RenderTarget")]
+public unsafe partial struct ID2D1BitmapRenderTarget
+{
+	public static ref readonly Guid IID_ID2D1BitmapRenderTarget
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x95, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1BitmapRenderTarget));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[3]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[6]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[7]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[8]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[9]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[10]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[11]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[12]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Mesh**, int>)(lpVtbl[13]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[14]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[16]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[17]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[18]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[19]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[20]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[21]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[22]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[24]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[25]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[26]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[27]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[28]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Matrix3x2*, void>)(lpVtbl[29]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Matrix3x2**, void>)(lpVtbl[30]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, AntialiasMode, void>)(lpVtbl[31]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[32]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, TextAntialiasMode, void>)(lpVtbl[33]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[34]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[35]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[36]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong, ulong, void>)(lpVtbl[37]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong*, ulong*, void>)(lpVtbl[38]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[39]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, void>)(lpVtbl[40]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong*, ulong*, int>)(lpVtbl[41]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[42]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[44]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, void>)(lpVtbl[45]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.ColorF*, void>)(lpVtbl[46]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, void>)(lpVtbl[47]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong*, ulong*, int>)(lpVtbl[48]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[49]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, float, float, void>)(lpVtbl[50]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, float*, float*, void>)(lpVtbl[51]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.SizeF>)(lpVtbl[52]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[53]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, uint>)(lpVtbl[54]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[55]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Factory**, void>)(lpVtbl[56]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapRenderTarget::GetBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public HResult GetBitmap(ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Bitmap**, int>)(lpVtbl[57]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), bitmap);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1HwndRenderTarget"]/*' />
+/// <unmanaged>ID2D1HwndRenderTarget</unmanaged>
+[Guid("2cd90698-12e2-11dc-9fed-001143a055f9")]
+[NativeTypeName("struct ID2D1HwndRenderTarget : ID2D1RenderTarget")]
+[NativeInheritance("ID2D1RenderTarget")]
+public unsafe partial struct ID2D1HwndRenderTarget
+{
+	public static ref readonly Guid IID_ID2D1HwndRenderTarget
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x98, 0x06, 0xD9, 0x2C,
+				0xE2, 0x12,
+				0xDC, 0x11,
+				0x9F,
+				0xED,
+				0x00,
+				0x11,
+				0x43,
+				0xA0,
+				0x55,
+				0xF9
+			};
+
+			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_ID2D1HwndRenderTarget));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[3]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[6]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[7]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[8]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[9]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[10]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[11]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[12]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Mesh**, int>)(lpVtbl[13]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[14]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[16]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[17]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[18]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[19]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[20]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[21]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[22]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[24]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[25]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[26]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[27]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[28]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Matrix3x2*, void>)(lpVtbl[29]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Matrix3x2**, void>)(lpVtbl[30]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, AntialiasMode, void>)(lpVtbl[31]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[32]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, TextAntialiasMode, void>)(lpVtbl[33]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[34]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[35]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[36]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong, ulong, void>)(lpVtbl[37]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong*, ulong*, void>)(lpVtbl[38]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[39]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, void>)(lpVtbl[40]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong*, ulong*, int>)(lpVtbl[41]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[42]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[44]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, void>)(lpVtbl[45]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.ColorF*, void>)(lpVtbl[46]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, void>)(lpVtbl[47]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong*, ulong*, int>)(lpVtbl[48]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[49]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, float, float, void>)(lpVtbl[50]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, float*, float*, void>)(lpVtbl[51]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.SizeF>)(lpVtbl[52]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[53]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, uint>)(lpVtbl[54]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[55]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Factory**, void>)(lpVtbl[56]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1HwndRenderTarget::CheckWindowState"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public Graphics.Direct2D.WindowState CheckWindowState()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Direct2D.WindowState>)(lpVtbl[57]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1HwndRenderTarget::Resize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public HResult Resize(Common.SizeU* pixelSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.SizeU*, int>)(lpVtbl[58]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), pixelSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1HwndRenderTarget::GetHwnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public IntPtr GetHwnd()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, IntPtr>)(lpVtbl[59]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiInteropRenderTarget"]/*' />
+/// <unmanaged>ID2D1GdiInteropRenderTarget</unmanaged>
+[Guid("e0db51c3-6f77-4bae-b3d5-e47509b35838")]
+[NativeTypeName("struct ID2D1GdiInteropRenderTarget : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1GdiInteropRenderTarget
+{
+	public static ref readonly Guid IID_ID2D1GdiInteropRenderTarget
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC3, 0x51, 0xDB, 0xE0,
+				0x77, 0x6F,
+				0xAE, 0x4B,
+				0xB3,
+				0xD5,
+				0xE4,
+				0x75,
+				0x09,
+				0xB3,
+				0x58,
+				0x38
+			};
+
+			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_ID2D1GdiInteropRenderTarget));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiInteropRenderTarget::GetDC"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetDC(DcInitializeMode mode, IntPtr* hdc)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiInteropRenderTarget*, DcInitializeMode, IntPtr*, int>)(lpVtbl[3]))((ID2D1GdiInteropRenderTarget*)Unsafe.AsPointer(ref this), mode, hdc);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiInteropRenderTarget::ReleaseDC"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult ReleaseDC(RawRect* update)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiInteropRenderTarget*, RawRect*, int>)(lpVtbl[4]))((ID2D1GdiInteropRenderTarget*)Unsafe.AsPointer(ref this), update);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DCRenderTarget"]/*' />
+/// <unmanaged>ID2D1DCRenderTarget</unmanaged>
+[Guid("1c51bc64-de61-46fd-9899-63a5d8f03950")]
+[NativeTypeName("struct ID2D1DCRenderTarget : ID2D1RenderTarget")]
+[NativeInheritance("ID2D1RenderTarget")]
+public unsafe partial struct ID2D1DCRenderTarget
+{
+	public static ref readonly Guid IID_ID2D1DCRenderTarget
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x64, 0xBC, 0x51, 0x1C,
+				0x61, 0xDE,
+				0xFD, 0x46,
+				0x98,
+				0x99,
+				0x63,
+				0xA5,
+				0xD8,
+				0xF0,
+				0x39,
+				0x50
+			};
+
+			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_ID2D1DCRenderTarget));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[3]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[6]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[7]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[8]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[9]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[10]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[11]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[12]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Mesh**, int>)(lpVtbl[13]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[14]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[16]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[17]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[18]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[19]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[20]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[21]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[22]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[24]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[26]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[27]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[28]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Matrix3x2*, void>)(lpVtbl[29]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Matrix3x2**, void>)(lpVtbl[30]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, AntialiasMode, void>)(lpVtbl[31]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[32]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, TextAntialiasMode, void>)(lpVtbl[33]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[34]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[35]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[36]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong, ulong, void>)(lpVtbl[37]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong*, ulong*, void>)(lpVtbl[38]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[39]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, void>)(lpVtbl[40]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong*, ulong*, int>)(lpVtbl[41]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[42]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[44]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, void>)(lpVtbl[45]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.ColorF*, void>)(lpVtbl[46]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, void>)(lpVtbl[47]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong*, ulong*, int>)(lpVtbl[48]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[49]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, float, float, void>)(lpVtbl[50]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, float*, float*, void>)(lpVtbl[51]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.SizeF>)(lpVtbl[52]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[53]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, uint>)(lpVtbl[54]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[55]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Factory**, void>)(lpVtbl[56]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DCRenderTarget::BindDC"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public HResult BindDC(IntPtr hDC, RawRect* pSubRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, IntPtr, RawRect*, int>)(lpVtbl[57]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), hDC, pSubRect);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory"]/*' />
+/// <unmanaged>ID2D1Factory</unmanaged>
+[Guid("06152247-6f50-465a-9245-118bfd3b6007")]
+[NativeTypeName("struct ID2D1Factory : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1Factory
+{
+	public static ref readonly Guid IID_ID2D1Factory
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x47, 0x22, 0x15, 0x06,
+				0x50, 0x6F,
+				0x5A, 0x46,
+				0x92,
+				0x45,
+				0x11,
+				0x8B,
+				0xFD,
+				0x3B,
+				0x60,
+				0x07
+			};
+
+			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_ID2D1Factory));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::ReloadSystemMetrics"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, int>)(lpVtbl[3]))((ID2D1Factory*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::GetDesktopDpi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateRectangleGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateRoundedRectangleGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateEllipseGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateGeometryGroup"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateTransformedGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreatePathGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateStrokeStyle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateDrawingStateBlock"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateWicBitmapRenderTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateHwndRenderTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateDxgiSurfaceRenderTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory::CreateDCRenderTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafileSink"]/*' />
+/// <unmanaged>ID2D1GdiMetafileSink</unmanaged>
+[Guid("82237326-8111-4f7c-bcf4-b5c1175564fe")]
+[NativeTypeName("struct ID2D1GdiMetafileSink : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1GdiMetafileSink
+{
+	public static ref readonly Guid IID_ID2D1GdiMetafileSink
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x26, 0x73, 0x23, 0x82,
+				0x11, 0x81,
+				0x7C, 0x4F,
+				0xBC,
+				0xF4,
+				0xB5,
+				0xC1,
+				0x17,
+				0x55,
+				0x64,
+				0xFE
+			};
+
+			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_ID2D1GdiMetafileSink));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafileSink::ProcessRecord"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult ProcessRecord(uint recordType, void* recordData, uint recordDataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafileSink*, uint, void*, uint, int>)(lpVtbl[3]))((ID2D1GdiMetafileSink*)Unsafe.AsPointer(ref this), recordType, recordData, recordDataSize);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafile"]/*' />
+/// <unmanaged>ID2D1GdiMetafile</unmanaged>
+[Guid("2f543dc3-cfc1-4211-864f-cfd91c6f3395")]
+[NativeTypeName("struct ID2D1GdiMetafile : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1GdiMetafile
+{
+	public static ref readonly Guid IID_ID2D1GdiMetafile
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC3, 0x3D, 0x54, 0x2F,
+				0xC1, 0xCF,
+				0x11, 0x42,
+				0x86,
+				0x4F,
+				0xCF,
+				0xD9,
+				0x1C,
+				0x6F,
+				0x33,
+				0x95
+			};
+
+			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_ID2D1GdiMetafile));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GdiMetafile*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafile::Stream"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Stream(ID2D1GdiMetafileSink* sink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile*, ID2D1GdiMetafileSink*, int>)(lpVtbl[4]))((ID2D1GdiMetafile*)Unsafe.AsPointer(ref this), sink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafile::GetBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetBounds(Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile*, Common.RectF*, int>)(lpVtbl[5]))((ID2D1GdiMetafile*)Unsafe.AsPointer(ref this), bounds);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink"]/*' />
+/// <unmanaged>ID2D1CommandSink</unmanaged>
+[Guid("54d7898a-a061-40a7-bec7-e465bcba2c4f")]
+[NativeTypeName("struct ID2D1CommandSink : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1CommandSink
+{
+	public static ref readonly Guid IID_ID2D1CommandSink
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x8A, 0x89, 0xD7, 0x54,
+				0x61, 0xA0,
+				0xA7, 0x40,
+				0xBE,
+				0xC7,
+				0xE4,
+				0x65,
+				0xBC,
+				0xBA,
+				0x2C,
+				0x4F
+			};
+
+			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_ID2D1CommandSink));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::BeginDraw"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult BeginDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, int>)(lpVtbl[3]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::EndDraw"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult EndDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, int>)(lpVtbl[4]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetAntialiasMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, AntialiasMode, int>)(lpVtbl[5]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetTags"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetTags(ulong tag1, ulong tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ulong, ulong, int>)(lpVtbl[6]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetTextAntialiasMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, TextAntialiasMode, int>)(lpVtbl[7]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetTextRenderingParams"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[8]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetTransform(Matrix3x2* transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, Matrix3x2*, int>)(lpVtbl[9]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetPrimitiveBlend"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, PrimitiveBlend, int>)(lpVtbl[10]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::SetUnitMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetUnitMode(UnitMode unitMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, UnitMode, int>)(lpVtbl[11]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::Clear"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult Clear(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, Common.ColorF*, int>)(lpVtbl[12]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawGlyphRun"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[13]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawLine"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[14]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[17]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[18]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::DrawGdiMetafile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[19]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::FillMesh"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[20]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::FillOpacityMask"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[21]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::FillGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[22]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::FillRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::PushAxisAlignedClip"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, Common.RectF*, AntialiasMode, int>)(lpVtbl[24]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::PushLayer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult PushLayer(LayerParameters1* layerParameters1, ID2D1Layer* layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[25]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this), layerParameters1, layer);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::PopAxisAlignedClip"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult PopAxisAlignedClip()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, int>)(lpVtbl[26]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink::PopLayer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult PopLayer()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink*, int>)(lpVtbl[27]))((ID2D1CommandSink*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandList"]/*' />
+/// <unmanaged>ID2D1CommandList</unmanaged>
+[Guid("b4f34a19-2383-4d76-94f6-ec343657c3dc")]
+[NativeTypeName("struct ID2D1CommandList : ID2D1Image")]
+[NativeInheritance("ID2D1Image")]
+public unsafe partial struct ID2D1CommandList
+{
+	public static ref readonly Guid IID_ID2D1CommandList
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x19, 0x4A, 0xF3, 0xB4,
+				0x83, 0x23,
+				0x76, 0x4D,
+				0x94,
+				0xF6,
+				0xEC,
+				0x34,
+				0x36,
+				0x57,
+				0xC3,
+				0xDC
+			};
+
+			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_ID2D1CommandList));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1CommandList*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1CommandList*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandList::Stream"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Stream(ID2D1CommandSink* sink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandList*, ID2D1CommandSink*, int>)(lpVtbl[4]))((ID2D1CommandList*)Unsafe.AsPointer(ref this), sink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandList::Close"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult Close()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandList*, int>)(lpVtbl[5]))((ID2D1CommandList*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PrintControl"]/*' />
+/// <unmanaged>ID2D1PrintControl</unmanaged>
+[Guid("2c1d867d-c290-41c8-ae7e-34a98702e9a5")]
+[NativeTypeName("struct ID2D1PrintControl : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1PrintControl
+{
+	public static ref readonly Guid IID_ID2D1PrintControl
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x7D, 0x86, 0x1D, 0x2C,
+				0x90, 0xC2,
+				0xC8, 0x41,
+				0xAE,
+				0x7E,
+				0x34,
+				0xA9,
+				0x87,
+				0x02,
+				0xE9,
+				0xA5
+			};
+
+			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_ID2D1PrintControl));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PrintControl::AddPage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult AddPage(ID2D1CommandList* commandList, System.Drawing.SizeF* pageSize, Com.IStream* pagePrintTicketStream, ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PrintControl*, ID2D1CommandList*, System.Drawing.SizeF*, Com.IStream*, ulong*, ulong*, int>)(lpVtbl[3]))((ID2D1PrintControl*)Unsafe.AsPointer(ref this), commandList, pageSize, pagePrintTicketStream, tag1, tag2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PrintControl::Close"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Close()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PrintControl*, int>)(lpVtbl[4]))((ID2D1PrintControl*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush"]/*' />
+/// <unmanaged>ID2D1ImageBrush</unmanaged>
+[Guid("fe9e984d-3f95-407c-b5db-cb94d4e8f87c")]
+[NativeTypeName("struct ID2D1ImageBrush : ID2D1Brush")]
+[NativeInheritance("ID2D1Brush")]
+public unsafe partial struct ID2D1ImageBrush
+{
+	public static ref readonly Guid IID_ID2D1ImageBrush
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4D, 0x98, 0x9E, 0xFE,
+				0x95, 0x3F,
+				0x7C, 0x40,
+				0xB5,
+				0xDB,
+				0xCB,
+				0x94,
+				0xD4,
+				0xE8,
+				0xF8,
+				0x7C
+			};
+
+			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_ID2D1ImageBrush));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, float, void>)(lpVtbl[3]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Matrix3x2*, void>)(lpVtbl[4]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, float>)(lpVtbl[5]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Matrix3x2**, void>)(lpVtbl[6]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::SetImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void SetImage(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ID2D1Image*, void>)(lpVtbl[8]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::SetExtendModeX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void SetExtendModeX(ExtendMode extendModeX)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ExtendMode, void>)(lpVtbl[9]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), extendModeX);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::SetExtendModeY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void SetExtendModeY(ExtendMode extendModeY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ExtendMode, void>)(lpVtbl[10]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), extendModeY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::SetInterpolationMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void SetInterpolationMode(InterpolationMode interpolationMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, InterpolationMode, void>)(lpVtbl[11]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), interpolationMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::SetSourceRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void SetSourceRectangle(Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Common.RectF*, void>)(lpVtbl[12]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), sourceRectangle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public void GetImage(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ID2D1Image**, void>)(lpVtbl[13]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetExtendModeX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeX()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Graphics.Direct2D.ExtendMode>)(lpVtbl[14]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetExtendModeY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeY()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Graphics.Direct2D.ExtendMode>)(lpVtbl[15]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetInterpolationMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public Graphics.Direct2D.InterpolationMode GetInterpolationMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Graphics.Direct2D.InterpolationMode>)(lpVtbl[16]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetSourceRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetSourceRectangle(Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Common.RectF*, void>)(lpVtbl[17]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), sourceRectangle);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush1"]/*' />
+/// <unmanaged>ID2D1BitmapBrush1</unmanaged>
+[Guid("41343a53-e41a-49a2-91cd-21793bbb62e5")]
+[NativeTypeName("struct ID2D1BitmapBrush1 : ID2D1BitmapBrush")]
+[NativeInheritance("ID2D1BitmapBrush")]
+public unsafe partial struct ID2D1BitmapBrush1
+{
+	public static ref readonly Guid IID_ID2D1BitmapBrush1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x53, 0x3A, 0x34, 0x41,
+				0x1A, 0xE4,
+				0xA2, 0x49,
+				0x91,
+				0xCD,
+				0x21,
+				0x79,
+				0x3B,
+				0xBB,
+				0x62,
+				0xE5
+			};
+
+			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_ID2D1BitmapBrush1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.SetExtendModeX" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void SetExtendModeX(ExtendMode extendModeX)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ExtendMode, void>)(lpVtbl[3]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), extendModeX);
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.SetExtendModeY" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetExtendModeY(ExtendMode extendModeY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ExtendMode, void>)(lpVtbl[4]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), extendModeY);
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.SetInterpolationMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetInterpolationMode(BitmapInterpolationMode interpolationMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, BitmapInterpolationMode, void>)(lpVtbl[5]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), interpolationMode);
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.SetBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetBitmap(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ID2D1Bitmap*, void>)(lpVtbl[6]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.GetExtendModeX" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeX()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Graphics.Direct2D.ExtendMode>)(lpVtbl[7]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.GetExtendModeY" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeY()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Graphics.Direct2D.ExtendMode>)(lpVtbl[8]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.GetInterpolationMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public Graphics.Direct2D.BitmapInterpolationMode GetInterpolationMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Graphics.Direct2D.BitmapInterpolationMode>)(lpVtbl[9]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1BitmapBrush.GetBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void GetBitmap(ID2D1Bitmap** bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ID2D1Bitmap**, void>)(lpVtbl[10]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void SetOpacity(float opacity)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, float, void>)(lpVtbl[11]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), opacity);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Matrix3x2*, void>)(lpVtbl[12]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public float GetOpacity()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, float>)(lpVtbl[13]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Brush.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Matrix3x2**, void>)(lpVtbl[14]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ID2D1Factory**, void>)(lpVtbl[15]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush1::SetInterpolationMode1"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void SetInterpolationMode1(InterpolationMode interpolationMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, InterpolationMode, void>)(lpVtbl[16]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), interpolationMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush1::GetInterpolationMode1"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public Graphics.Direct2D.InterpolationMode GetInterpolationMode1()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Graphics.Direct2D.InterpolationMode>)(lpVtbl[17]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle1"]/*' />
+/// <unmanaged>ID2D1StrokeStyle1</unmanaged>
+[Guid("10a72a66-e91c-43f4-993f-ddf4b82b0b4a")]
+[NativeTypeName("struct ID2D1StrokeStyle1 : ID2D1StrokeStyle")]
+[NativeInheritance("ID2D1StrokeStyle")]
+public unsafe partial struct ID2D1StrokeStyle1
+{
+	public static ref readonly Guid IID_ID2D1StrokeStyle1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x66, 0x2A, 0xA7, 0x10,
+				0x1C, 0xE9,
+				0xF4, 0x43,
+				0x99,
+				0x3F,
+				0xDD,
+				0xF4,
+				0xB8,
+				0x2B,
+				0x0B,
+				0x4A
+			};
+
+			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_ID2D1StrokeStyle1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetStartCap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public Graphics.Direct2D.CapStyle GetStartCap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, Graphics.Direct2D.CapStyle>)(lpVtbl[3]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetEndCap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public Graphics.Direct2D.CapStyle GetEndCap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, Graphics.Direct2D.CapStyle>)(lpVtbl[4]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetDashCap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public Graphics.Direct2D.CapStyle GetDashCap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, Graphics.Direct2D.CapStyle>)(lpVtbl[5]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetMiterLimit" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public float GetMiterLimit()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, float>)(lpVtbl[6]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetLineJoin" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.LineJoin GetLineJoin()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, Graphics.Direct2D.LineJoin>)(lpVtbl[7]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetDashOffset" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public float GetDashOffset()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, float>)(lpVtbl[8]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetDashStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public Graphics.Direct2D.DashStyle GetDashStyle()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, Graphics.Direct2D.DashStyle>)(lpVtbl[9]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetDashesCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public uint GetDashesCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, uint>)(lpVtbl[10]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1StrokeStyle.GetDashes" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void GetDashes(float* dashes, uint dashesCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, float*, uint, void>)(lpVtbl[11]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this), dashes, dashesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, ID2D1Factory**, void>)(lpVtbl[12]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1StrokeStyle1::GetStrokeTransformType"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public Graphics.Direct2D.StrokeTransformType GetStrokeTransformType()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1StrokeStyle1*, Graphics.Direct2D.StrokeTransformType>)(lpVtbl[13]))((ID2D1StrokeStyle1*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry1"]/*' />
+/// <unmanaged>ID2D1PathGeometry1</unmanaged>
+[Guid("62baa2d2-ab54-41b7-b872-787e0106a421")]
+[NativeTypeName("struct ID2D1PathGeometry1 : ID2D1PathGeometry")]
+[NativeInheritance("ID2D1PathGeometry")]
+public unsafe partial struct ID2D1PathGeometry1
+{
+	public static ref readonly Guid IID_ID2D1PathGeometry1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD2, 0xA2, 0xBA, 0x62,
+				0x54, 0xAB,
+				0xB7, 0x41,
+				0xB8,
+				0x72,
+				0x78,
+				0x7E,
+				0x01,
+				0x06,
+				0xA4,
+				0x21
+			};
+
+			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_ID2D1PathGeometry1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1PathGeometry.Open" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Open(ID2D1GeometrySink** geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1GeometrySink**, int>)(lpVtbl[3]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1PathGeometry.Stream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Stream(ID2D1GeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1GeometrySink*, int>)(lpVtbl[4]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1PathGeometry.GetSegmentCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetSegmentCount(uint* count)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, uint*, int>)(lpVtbl[5]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), count);
+	}
+
+	/// <inheritdoc cref="ID2D1PathGeometry.GetFigureCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetFigureCount(uint* count)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, uint*, int>)(lpVtbl[6]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), count);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[7]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.GetWidenedBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult GetWidenedBounds(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[8]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.StrokeContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult StrokeContainsPoint(System.Drawing.PointF* point, float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[9]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult FillContainsPoint(System.Drawing.PointF* point, Matrix3x2* worldTransform, float flatteningTolerance, Bool32* contains)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, System.Drawing.PointF*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[10]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[11]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Simplify" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[13]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.CombineWithGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CombineWithGeometry(ID2D1Geometry* inputGeometry, CombineMode combineMode, Matrix3x2* inputGeometryTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[14]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Outline" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[15]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, float*, int>)(lpVtbl[16]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, float*, int>)(lpVtbl[17]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.ComputePointAtLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult ComputePointAtLength(float length, Matrix3x2* worldTransform, float flatteningTolerance, System.Drawing.PointF** point, System.Drawing.PointF** unitTangentVector)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[18]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
+	}
+
+	/// <inheritdoc cref="ID2D1Geometry.Widen" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult Widen(float strokeWidth, ID2D1StrokeStyle* strokeStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[19]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1Factory**, void>)(lpVtbl[20]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1PathGeometry1::ComputePointAndSegmentAtLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult ComputePointAndSegmentAtLength(float length, uint startSegment, Matrix3x2* worldTransform, float flatteningTolerance, PointDescription* pointDescription)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, float, uint, Matrix3x2*, float, PointDescription*, int>)(lpVtbl[21]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), length, startSegment, worldTransform, flatteningTolerance, pointDescription);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties"]/*' />
+/// <unmanaged>ID2D1Properties</unmanaged>
+[Guid("483473d7-cd46-4f9d-9d3a-3112aa80159d")]
+[NativeTypeName("struct ID2D1Properties : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1Properties
+{
+	public static ref readonly Guid IID_ID2D1Properties
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD7, 0x73, 0x34, 0x48,
+				0x46, 0xCD,
+				0x9D, 0x4F,
+				0x9D,
+				0x3A,
+				0x31,
+				0x12,
+				0xAA,
+				0x80,
+				0x15,
+				0x9D
+			};
+
+			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_ID2D1Properties));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetPropertyCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetPropertyCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint>)(lpVtbl[3]))((ID2D1Properties*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetPropertyName"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetPropertyName(uint index, ushort* name, uint nameCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, ushort*, uint, int>)(lpVtbl[4]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index, name, nameCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetPropertyNameLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public uint GetPropertyNameLength(uint index)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, uint>)(lpVtbl[5]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetType"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.PropertyType GetType(uint index)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, Graphics.Direct2D.PropertyType>)(lpVtbl[6]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetPropertyIndex"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public uint GetPropertyIndex(ushort* name)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, ushort*, uint>)(lpVtbl[7]))((ID2D1Properties*)Unsafe.AsPointer(ref this), name);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::SetValueByName"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetValueByName(ushort* name, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, ushort*, PropertyType, byte*, uint, int>)(lpVtbl[8]))((ID2D1Properties*)Unsafe.AsPointer(ref this), name, type, data, dataSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::SetValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetValue(uint index, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, PropertyType, byte*, uint, int>)(lpVtbl[9]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index, type, data, dataSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetValueByName"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult GetValueByName(ushort* name, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, ushort*, PropertyType, byte*, uint, int>)(lpVtbl[10]))((ID2D1Properties*)Unsafe.AsPointer(ref this), name, type, data, dataSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetValue(uint index, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, PropertyType, byte*, uint, int>)(lpVtbl[11]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index, type, data, dataSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetValueSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public uint GetValueSize(uint index)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, uint>)(lpVtbl[12]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Properties::GetSubProperties"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetSubProperties(uint index, ID2D1Properties** subProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, ID2D1Properties**, int>)(lpVtbl[13]))((ID2D1Properties*)Unsafe.AsPointer(ref this), index, subProperties);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Effect"]/*' />
+/// <unmanaged>ID2D1Effect</unmanaged>
+[Guid("28211a43-7d89-476f-8181-2d6159b220ad")]
+[NativeTypeName("struct ID2D1Effect : ID2D1Properties")]
+[NativeInheritance("ID2D1Properties")]
+public unsafe partial struct ID2D1Effect
+{
+	public static ref readonly Guid IID_ID2D1Effect
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x43, 0x1A, 0x21, 0x28,
+				0x89, 0x7D,
+				0x6F, 0x47,
+				0x81,
+				0x81,
+				0x2D,
+				0x61,
+				0x59,
+				0xB2,
+				0x20,
+				0xAD
+			};
+
+			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_ID2D1Effect));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetPropertyCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetPropertyCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint>)(lpVtbl[3]))((ID2D1Effect*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetPropertyName" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetPropertyName(uint index, ushort* name, uint nameCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, ushort*, uint, int>)(lpVtbl[4]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index, name, nameCount);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetPropertyNameLength" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public uint GetPropertyNameLength(uint index)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, uint>)(lpVtbl[5]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetType" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.PropertyType GetType(uint index)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, Graphics.Direct2D.PropertyType>)(lpVtbl[6]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetPropertyIndex" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public uint GetPropertyIndex(ushort* name)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, ushort*, uint>)(lpVtbl[7]))((ID2D1Effect*)Unsafe.AsPointer(ref this), name);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.SetValueByName" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetValueByName(ushort* name, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, ushort*, PropertyType, byte*, uint, int>)(lpVtbl[8]))((ID2D1Effect*)Unsafe.AsPointer(ref this), name, type, data, dataSize);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.SetValue" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetValue(uint index, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, PropertyType, byte*, uint, int>)(lpVtbl[9]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index, type, data, dataSize);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetValueByName" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult GetValueByName(ushort* name, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, ushort*, PropertyType, byte*, uint, int>)(lpVtbl[10]))((ID2D1Effect*)Unsafe.AsPointer(ref this), name, type, data, dataSize);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetValue" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetValue(uint index, PropertyType type, byte* data, uint dataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, PropertyType, byte*, uint, int>)(lpVtbl[11]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index, type, data, dataSize);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetValueSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public uint GetValueSize(uint index)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, uint>)(lpVtbl[12]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index);
+	}
+
+	/// <inheritdoc cref="ID2D1Properties.GetSubProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetSubProperties(uint index, ID2D1Properties** subProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, ID2D1Properties**, int>)(lpVtbl[13]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index, subProperties);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Effect::SetInput"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void SetInput(uint index, ID2D1Image* input, Bool32 invalidate)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, ID2D1Image*, Bool32, void>)(lpVtbl[14]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index, input, invalidate);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Effect::SetInputCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult SetInputCount(uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, int>)(lpVtbl[15]))((ID2D1Effect*)Unsafe.AsPointer(ref this), inputCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Effect::GetInput"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetInput(uint index, ID2D1Image** input)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, ID2D1Image**, void>)(lpVtbl[16]))((ID2D1Effect*)Unsafe.AsPointer(ref this), index, input);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Effect::GetInputCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint>)(lpVtbl[17]))((ID2D1Effect*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Effect::GetOutput"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void GetOutput(ID2D1Image** outputImage)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Effect*, ID2D1Image**, void>)(lpVtbl[18]))((ID2D1Effect*)Unsafe.AsPointer(ref this), outputImage);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap1"]/*' />
+/// <unmanaged>ID2D1Bitmap1</unmanaged>
+[Guid("a898a84c-3873-4588-b08b-ebbf978df041")]
+[NativeTypeName("struct ID2D1Bitmap1 : ID2D1Bitmap")]
+[NativeInheritance("ID2D1Bitmap")]
+public unsafe partial struct ID2D1Bitmap1
+{
+	public static ref readonly Guid IID_ID2D1Bitmap1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4C, 0xA8, 0x98, 0xA8,
+				0x73, 0x38,
+				0x88, 0x45,
+				0xB0,
+				0x8B,
+				0xEB,
+				0xBF,
+				0x97,
+				0x8D,
+				0xF0,
+				0x41
+			};
+
+			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_ID2D1Bitmap1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, System.Drawing.SizeF>)(lpVtbl[3]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[4]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[5]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, float*, float*, void>)(lpVtbl[6]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.CopyFromBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CopyFromBitmap(Common.Point2u* destPoint, ID2D1Bitmap* bitmap, Common.RectU* srcRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Common.Point2u*, ID2D1Bitmap*, Common.RectU*, int>)(lpVtbl[7]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), destPoint, bitmap, srcRect);
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.CopyFromRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CopyFromRenderTarget(Common.Point2u* destPoint, ID2D1RenderTarget* renderTarget, Common.RectU* srcRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Common.Point2u*, ID2D1RenderTarget*, Common.RectU*, int>)(lpVtbl[8]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), destPoint, renderTarget, srcRect);
+	}
+
+	/// <inheritdoc cref="ID2D1Bitmap.CopyFromMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CopyFromMemory(Common.RectU* dstRect, void* srcData, uint pitch)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Common.RectU*, void*, uint, int>)(lpVtbl[9]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), dstRect, srcData, pitch);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, ID2D1Factory**, void>)(lpVtbl[10]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap1::GetColorContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void GetColorContext(ID2D1ColorContext** colorContext)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, ID2D1ColorContext**, void>)(lpVtbl[11]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap1::GetOptions"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public Graphics.Direct2D.BitmapOptions GetOptions()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Graphics.Direct2D.BitmapOptions>)(lpVtbl[12]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap1::GetSurface"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetSurface(Graphics.Dxgi.IDXGISurface** dxgiSurface)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Graphics.Dxgi.IDXGISurface**, int>)(lpVtbl[13]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), dxgiSurface);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap1::Map"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult Map(MapOptions options, MappedRect* mappedRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, MapOptions, MappedRect*, int>)(lpVtbl[14]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), options, mappedRect);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap1::Unmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult Unmap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, int>)(lpVtbl[15]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext"]/*' />
+/// <unmanaged>ID2D1ColorContext</unmanaged>
+[Guid("1c4820bb-5771-4518-a581-2fe4dd0ec657")]
+[NativeTypeName("struct ID2D1ColorContext : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1ColorContext
+{
+	public static ref readonly Guid IID_ID2D1ColorContext
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBB, 0x20, 0x48, 0x1C,
+				0x71, 0x57,
+				0x18, 0x45,
+				0xA5,
+				0x81,
+				0x2F,
+				0xE4,
+				0xDD,
+				0x0E,
+				0xC6,
+				0x57
+			};
+
+			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_ID2D1ColorContext));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ColorContext*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1ColorContext*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext::GetColorSpace"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public Graphics.Direct2D.ColorSpace GetColorSpace()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext*, Graphics.Direct2D.ColorSpace>)(lpVtbl[4]))((ID2D1ColorContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext::GetProfileSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public uint GetProfileSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext*, uint>)(lpVtbl[5]))((ID2D1ColorContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext::GetProfile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetProfile(byte* profile, uint profileSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext*, byte*, uint, int>)(lpVtbl[6]))((ID2D1ColorContext*)Unsafe.AsPointer(ref this), profile, profileSize);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1"]/*' />
+/// <unmanaged>ID2D1GradientStopCollection1</unmanaged>
+[Guid("ae1572f4-5dd0-4777-998b-9279472ae63b")]
+[NativeTypeName("struct ID2D1GradientStopCollection1 : ID2D1GradientStopCollection")]
+[NativeInheritance("ID2D1GradientStopCollection")]
+public unsafe partial struct ID2D1GradientStopCollection1
+{
+	public static ref readonly Guid IID_ID2D1GradientStopCollection1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xF4, 0x72, 0x15, 0xAE,
+				0xD0, 0x5D,
+				0x77, 0x47,
+				0x99,
+				0x8B,
+				0x92,
+				0x79,
+				0x47,
+				0x2A,
+				0xE6,
+				0x3B
+			};
+
+			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_ID2D1GradientStopCollection1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1GradientStopCollection.GetGradientStopCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetGradientStopCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, uint>)(lpVtbl[3]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1GradientStopCollection.GetGradientStops" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetGradientStops(GradientStop* gradientStops, uint gradientStopsCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, GradientStop*, uint, void>)(lpVtbl[4]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount);
+	}
+
+	/// <inheritdoc cref="ID2D1GradientStopCollection.GetColorInterpolationGamma" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public Graphics.Direct2D.Gamma GetColorInterpolationGamma()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Graphics.Direct2D.Gamma>)(lpVtbl[5]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1GradientStopCollection.GetExtendMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.ExtendMode GetExtendMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Graphics.Direct2D.ExtendMode>)(lpVtbl[6]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetGradientStops1"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void GetGradientStops1(GradientStop* gradientStops, uint gradientStopsCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, GradientStop*, uint, void>)(lpVtbl[8]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetPreInterpolationSpace"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public Graphics.Direct2D.ColorSpace GetPreInterpolationSpace()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Graphics.Direct2D.ColorSpace>)(lpVtbl[9]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetPostInterpolationSpace"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public Graphics.Direct2D.ColorSpace GetPostInterpolationSpace()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Graphics.Direct2D.ColorSpace>)(lpVtbl[10]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetBufferPrecision"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public Graphics.Direct2D.BufferPrecision GetBufferPrecision()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Graphics.Direct2D.BufferPrecision>)(lpVtbl[11]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetColorInterpolationMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public Graphics.Direct2D.ColorInterpolationMode GetColorInterpolationMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Graphics.Direct2D.ColorInterpolationMode>)(lpVtbl[12]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock1"]/*' />
+/// <unmanaged>ID2D1DrawingStateBlock1</unmanaged>
+[Guid("689f1f85-c72e-4e33-8f19-85754efd5ace")]
+[NativeTypeName("struct ID2D1DrawingStateBlock1 : ID2D1DrawingStateBlock")]
+[NativeInheritance("ID2D1DrawingStateBlock")]
+public unsafe partial struct ID2D1DrawingStateBlock1
+{
+	public static ref readonly Guid IID_ID2D1DrawingStateBlock1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x85, 0x1F, 0x9F, 0x68,
+				0x2E, 0xC7,
+				0x33, 0x4E,
+				0x8F,
+				0x19,
+				0x85,
+				0x75,
+				0x4E,
+				0xFD,
+				0x5A,
+				0xCE
+			};
+
+			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_ID2D1DrawingStateBlock1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DrawingStateBlock.GetDescription" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetDescription(DrawingStateDescription* stateDescription)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, DrawingStateDescription*, void>)(lpVtbl[3]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), stateDescription);
+	}
+
+	/// <inheritdoc cref="ID2D1DrawingStateBlock.SetDescription" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetDescription(DrawingStateDescription* stateDescription)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, DrawingStateDescription*, void>)(lpVtbl[4]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), stateDescription);
+	}
+
+	/// <inheritdoc cref="ID2D1DrawingStateBlock.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[5]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1DrawingStateBlock.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[6]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock1::GetDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void GetDescription(DrawingStateDescription1* stateDescription)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, DrawingStateDescription1*, void>)(lpVtbl[8]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), stateDescription);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawingStateBlock1::SetDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void SetDescription(DrawingStateDescription1* stateDescription)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, DrawingStateDescription1*, void>)(lpVtbl[9]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), stateDescription);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext"]/*' />
+/// <unmanaged>ID2D1DeviceContext</unmanaged>
+[Guid("e8f7fe7a-191c-466d-ad95-975678bda998")]
+[NativeTypeName("struct ID2D1DeviceContext : ID2D1RenderTarget")]
+[NativeInheritance("ID2D1RenderTarget")]
+public unsafe partial struct ID2D1DeviceContext
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x7A, 0xFE, 0xF7, 0xE8,
+				0x1C, 0x19,
+				0x6D, 0x46,
+				0xAD,
+				0x95,
+				0x97,
+				0x56,
+				0x78,
+				0xBD,
+				0xA9,
+				0x98
+			};
+
+			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_ID2D1DeviceContext));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[3]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[6]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[7]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[8]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[9]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[10]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[11]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[12]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Mesh**, int>)(lpVtbl[13]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[14]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[16]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[17]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[18]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[19]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[20]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[21]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[22]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[24]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[26]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[27]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[28]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Matrix3x2*, void>)(lpVtbl[29]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Matrix3x2**, void>)(lpVtbl[30]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, AntialiasMode, void>)(lpVtbl[31]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[32]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, TextAntialiasMode, void>)(lpVtbl[33]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[34]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[35]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[36]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong, ulong, void>)(lpVtbl[37]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong*, ulong*, void>)(lpVtbl[38]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[39]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, void>)(lpVtbl[40]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong*, ulong*, int>)(lpVtbl[41]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1DrawingStateBlock*, void>)(lpVtbl[42]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.RectF*, AntialiasMode, void>)(lpVtbl[44]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, void>)(lpVtbl[45]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.ColorF*, void>)(lpVtbl[46]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, void>)(lpVtbl[47]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong*, ulong*, int>)(lpVtbl[48]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[49]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, float, float, void>)(lpVtbl[50]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, float*, float*, void>)(lpVtbl[51]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.SizeF>)(lpVtbl[52]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[53]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, uint>)(lpVtbl[54]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RenderTargetProperties*, Bool32>)(lpVtbl[55]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Factory**, void>)(lpVtbl[56]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[57]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateBitmapFromWicBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[58]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateColorContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[59]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateColorContextFromFilename"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[60]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateColorContextFromWicColorContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[61]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateBitmapFromDxgiSurface"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[62]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateEffect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Guid*, ID2D1Effect**, int>)(lpVtbl[63]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateGradientStopCollection"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[64]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateImageBrush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[65]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateBitmapBrush"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[66]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateCommandList"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1CommandList**, int>)(lpVtbl[67]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::IsDxgiFormatSupported"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[68]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::IsBufferPrecisionSupported"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, BufferPrecision, Bool32>)(lpVtbl[69]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetImageLocalBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[70]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetImageWorldBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[71]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetGlyphRunWorldBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[72]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Device**, void>)(lpVtbl[73]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::SetTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Image*, void>)(lpVtbl[74]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetTarget"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Image**, void>)(lpVtbl[75]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::SetRenderingControls"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RenderingControls*, void>)(lpVtbl[76]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetRenderingControls"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RenderingControls*, void>)(lpVtbl[77]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::SetPrimitiveBlend"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, PrimitiveBlend, void>)(lpVtbl[78]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetPrimitiveBlend"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[79]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::SetUnitMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, UnitMode, void>)(lpVtbl[80]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetUnitMode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Direct2D.UnitMode>)(lpVtbl[81]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::DrawGlyphRun"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[82]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::DrawImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[83]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::DrawGdiMetafile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[84]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::DrawBitmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[85]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::PushLayer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[86]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::InvalidateEffectInputRectangle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[87]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetEffectInvalidRectangleCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Effect*, uint*, int>)(lpVtbl[88]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetEffectInvalidRectangles"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[89]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::GetEffectRequiredInputRectangles"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[90]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::FillOpacityMask"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[91]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device"]/*' />
+/// <unmanaged>ID2D1Device</unmanaged>
+[Guid("47dd575d-ac05-4cdd-8049-9b02cd16f44c")]
+[NativeTypeName("struct ID2D1Device : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Device
+{
+	public static ref readonly Guid IID_ID2D1Device
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x5D, 0x57, 0xDD, 0x47,
+				0x05, 0xAC,
+				0xDD, 0x4C,
+				0x80,
+				0x49,
+				0x9B,
+				0x02,
+				0xCD,
+				0x16,
+				0xF4,
+				0x4C
+			};
+
+			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_ID2D1Device));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device::SetMaximumTextureMemory"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device*, ulong, void>)(lpVtbl[5]))((ID2D1Device*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device::GetMaximumTextureMemory"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device*, ulong>)(lpVtbl[6]))((ID2D1Device*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device::ClearResources"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device*, uint, void>)(lpVtbl[7]))((ID2D1Device*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1"]/*' />
+/// <unmanaged>ID2D1Factory1</unmanaged>
+[Guid("bb12d362-daee-4b9a-aa1d-14ba401cfa1f")]
+[NativeTypeName("struct ID2D1Factory1 : ID2D1Factory")]
+[NativeInheritance("ID2D1Factory")]
+public unsafe partial struct ID2D1Factory1
+{
+	public static ref readonly Guid IID_ID2D1Factory1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x62, 0xD3, 0x12, 0xBB,
+				0xEE, 0xDA,
+				0x9A, 0x4B,
+				0xAA,
+				0x1D,
+				0x14,
+				0xBA,
+				0x40,
+				0x1C,
+				0xFA,
+				0x1F
+			};
+
+			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_ID2D1Factory1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, int>)(lpVtbl[3]))((ID2D1Factory1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory1*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::CreateStrokeStyle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::CreatePathGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::CreateDrawingStateBlock"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::CreateGdiMetafile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::RegisterEffectFromStream"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::RegisterEffectFromString"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::UnregisterEffect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::GetRegisteredEffects"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory1::GetEffectProperties"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory1*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory1*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Multithread"]/*' />
+/// <unmanaged>ID2D1Multithread</unmanaged>
+[Guid("31e6e7bc-e0ff-4d46-8c64-a0a8c41c15d3")]
+[NativeTypeName("struct ID2D1Multithread : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1Multithread
+{
+	public static ref readonly Guid IID_ID2D1Multithread
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBC, 0xE7, 0xE6, 0x31,
+				0xFF, 0xE0,
+				0x46, 0x4D,
+				0x8C,
+				0x64,
+				0xA0,
+				0xA8,
+				0xC4,
+				0x1C,
+				0x15,
+				0xD3
+			};
+
+			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_ID2D1Multithread));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Multithread::GetMultithreadProtected"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public Bool32 GetMultithreadProtected()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Multithread*, Bool32>)(lpVtbl[3]))((ID2D1Multithread*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Multithread::Enter"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void Enter()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Multithread*, void>)(lpVtbl[4]))((ID2D1Multithread*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Multithread::Leave"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void Leave()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Multithread*, void>)(lpVtbl[5]))((ID2D1Multithread*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1VertexBuffer"]/*' />
+/// <unmanaged>ID2D1VertexBuffer</unmanaged>
+[Guid("9b8b1336-00a5-4668-92b7-ced5d8bf9b7b")]
+[NativeTypeName("struct ID2D1VertexBuffer : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1VertexBuffer
+{
+	public static ref readonly Guid IID_ID2D1VertexBuffer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x36, 0x13, 0x8B, 0x9B,
+				0xA5, 0x00,
+				0x68, 0x46,
+				0x92,
+				0xB7,
+				0xCE,
+				0xD5,
+				0xD8,
+				0xBF,
+				0x9B,
+				0x7B
+			};
+
+			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_ID2D1VertexBuffer));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1VertexBuffer::Map"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Map(byte** data, uint bufferSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1VertexBuffer*, byte**, uint, int>)(lpVtbl[3]))((ID2D1VertexBuffer*)Unsafe.AsPointer(ref this), data, bufferSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1VertexBuffer::Unmap"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Unmap()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1VertexBuffer*, int>)(lpVtbl[4]))((ID2D1VertexBuffer*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ResourceTexture"]/*' />
+/// <unmanaged>ID2D1ResourceTexture</unmanaged>
+[Guid("688d15c3-02b0-438d-b13a-d1b44c32c39a")]
+[NativeTypeName("struct ID2D1ResourceTexture : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1ResourceTexture
+{
+	public static ref readonly Guid IID_ID2D1ResourceTexture
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xC3, 0x15, 0x8D, 0x68,
+				0xB0, 0x02,
+				0x8D, 0x43,
+				0xB1,
+				0x3A,
+				0xD1,
+				0xB4,
+				0x4C,
+				0x32,
+				0xC3,
+				0x9A
+			};
+
+			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_ID2D1ResourceTexture));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ResourceTexture::Update"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Update(uint* minimumExtents, uint* maximimumExtents, uint* strides, uint dimensions, byte* data, uint dataCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ResourceTexture*, uint*, uint*, uint*, uint, byte*, uint, int>)(lpVtbl[3]))((ID2D1ResourceTexture*)Unsafe.AsPointer(ref this), minimumExtents, maximimumExtents, strides, dimensions, data, dataCount);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderInfo"]/*' />
+/// <unmanaged>ID2D1RenderInfo</unmanaged>
+[Guid("519ae1bd-d19a-420d-b849-364f594776b7")]
+[NativeTypeName("struct ID2D1RenderInfo : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1RenderInfo
+{
+	public static ref readonly Guid IID_ID2D1RenderInfo
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBD, 0xE1, 0x9A, 0x51,
+				0x9A, 0xD1,
+				0x0D, 0x42,
+				0xB8,
+				0x49,
+				0x36,
+				0x4F,
+				0x59,
+				0x47,
+				0x76,
+				0xB7
+			};
+
+			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_ID2D1RenderInfo));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderInfo::SetInputDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetInputDescription(uint inputIndex, InputDescription* inputDescription)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderInfo*, uint, InputDescription*, int>)(lpVtbl[3]))((ID2D1RenderInfo*)Unsafe.AsPointer(ref this), inputIndex, inputDescription);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderInfo::SetOutputBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1RenderInfo*, BufferPrecision, ChannelDepth, int>)(lpVtbl[4]))((ID2D1RenderInfo*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderInfo::SetCached"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetCached(Bool32 isCached)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderInfo*, Bool32, void>)(lpVtbl[5]))((ID2D1RenderInfo*)Unsafe.AsPointer(ref this), isCached);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1RenderInfo::SetInstructionCountHint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetInstructionCountHint(uint instructionCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1RenderInfo*, uint, void>)(lpVtbl[6]))((ID2D1RenderInfo*)Unsafe.AsPointer(ref this), instructionCount);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawInfo"]/*' />
+/// <unmanaged>ID2D1DrawInfo</unmanaged>
+[Guid("693ce632-7f2f-45de-93fe-18d88b37aa21")]
+[NativeTypeName("struct ID2D1DrawInfo : ID2D1RenderInfo")]
+[NativeInheritance("ID2D1RenderInfo")]
+public unsafe partial struct ID2D1DrawInfo
+{
+	public static ref readonly Guid IID_ID2D1DrawInfo
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x32, 0xE6, 0x3C, 0x69,
+				0x2F, 0x7F,
+				0xDE, 0x45,
+				0x93,
+				0xFE,
+				0x18,
+				0xD8,
+				0x8B,
+				0x37,
+				0xAA,
+				0x21
+			};
+
+			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_ID2D1DrawInfo));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetInputDescription" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetInputDescription(uint inputIndex, InputDescription* inputDescription)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, uint, InputDescription*, int>)(lpVtbl[3]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), inputIndex, inputDescription);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetOutputBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, BufferPrecision, ChannelDepth, int>)(lpVtbl[4]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetCached" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetCached(Bool32 isCached)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, Bool32, void>)(lpVtbl[5]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), isCached);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetInstructionCountHint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetInstructionCountHint(uint instructionCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, uint, void>)(lpVtbl[6]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), instructionCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawInfo::SetPixelShaderConstantBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetPixelShaderConstantBuffer(byte* buffer, uint bufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, byte*, uint, int>)(lpVtbl[7]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), buffer, bufferCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawInfo::SetResourceTexture"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetResourceTexture(uint textureIndex, ID2D1ResourceTexture* resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, uint, ID2D1ResourceTexture*, int>)(lpVtbl[8]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), textureIndex, resourceTexture);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawInfo::SetVertexShaderConstantBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetVertexShaderConstantBuffer(byte* buffer, uint bufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, byte*, uint, int>)(lpVtbl[9]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), buffer, bufferCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawInfo::SetPixelShader"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetPixelShader(Guid* shaderId, PixelOptions pixelOptions)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, Guid*, PixelOptions, int>)(lpVtbl[10]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), shaderId, pixelOptions);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawInfo::SetVertexProcessing"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetVertexProcessing(ID2D1VertexBuffer* vertexBuffer, VertexOptions vertexOptions, BlendDescription* blendDescription, VertexRange* vertexRange, Guid* vertexShader)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawInfo*, ID2D1VertexBuffer*, VertexOptions, BlendDescription*, VertexRange*, Guid*, int>)(lpVtbl[11]))((ID2D1DrawInfo*)Unsafe.AsPointer(ref this), vertexBuffer, vertexOptions, blendDescription, vertexRange, vertexShader);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeInfo"]/*' />
+/// <unmanaged>ID2D1ComputeInfo</unmanaged>
+[Guid("5598b14b-9fd7-48b7-9bdb-8f0964eb38bc")]
+[NativeTypeName("struct ID2D1ComputeInfo : ID2D1RenderInfo")]
+[NativeInheritance("ID2D1RenderInfo")]
+public unsafe partial struct ID2D1ComputeInfo
+{
+	public static ref readonly Guid IID_ID2D1ComputeInfo
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4B, 0xB1, 0x98, 0x55,
+				0xD7, 0x9F,
+				0xB7, 0x48,
+				0x9B,
+				0xDB,
+				0x8F,
+				0x09,
+				0x64,
+				0xEB,
+				0x38,
+				0xBC
+			};
+
+			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_ID2D1ComputeInfo));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetInputDescription" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetInputDescription(uint inputIndex, InputDescription* inputDescription)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, uint, InputDescription*, int>)(lpVtbl[3]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), inputIndex, inputDescription);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetOutputBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, BufferPrecision, ChannelDepth, int>)(lpVtbl[4]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetCached" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetCached(Bool32 isCached)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, Bool32, void>)(lpVtbl[5]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), isCached);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderInfo.SetInstructionCountHint" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetInstructionCountHint(uint instructionCount)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, uint, void>)(lpVtbl[6]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), instructionCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeInfo::SetComputeShaderConstantBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetComputeShaderConstantBuffer(byte* buffer, uint bufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, byte*, uint, int>)(lpVtbl[7]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), buffer, bufferCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeInfo::SetComputeShader"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetComputeShader(Guid* shaderId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, Guid*, int>)(lpVtbl[8]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), shaderId);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeInfo::SetResourceTexture"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetResourceTexture(uint textureIndex, ID2D1ResourceTexture* resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeInfo*, uint, ID2D1ResourceTexture*, int>)(lpVtbl[9]))((ID2D1ComputeInfo*)Unsafe.AsPointer(ref this), textureIndex, resourceTexture);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformNode"]/*' />
+/// <unmanaged>ID2D1TransformNode</unmanaged>
+[Guid("b2efe1e7-729f-4102-949f-505fa21bf666")]
+[NativeTypeName("struct ID2D1TransformNode : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1TransformNode
+{
+	public static ref readonly Guid IID_ID2D1TransformNode
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE7, 0xE1, 0xEF, 0xB2,
+				0x9F, 0x72,
+				0x02, 0x41,
+				0x94,
+				0x9F,
+				0x50,
+				0x5F,
+				0xA2,
+				0x1B,
+				0xF6,
+				0x66
+			};
+
+			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_ID2D1TransformNode));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformNode::GetInputCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformNode*, uint>)(lpVtbl[3]))((ID2D1TransformNode*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph"]/*' />
+/// <unmanaged>ID2D1TransformGraph</unmanaged>
+[Guid("13d29038-c3e6-4034-9081-13b53a417992")]
+[NativeTypeName("struct ID2D1TransformGraph : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1TransformGraph
+{
+	public static ref readonly Guid IID_ID2D1TransformGraph
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x38, 0x90, 0xD2, 0x13,
+				0xE6, 0xC3,
+				0x34, 0x40,
+				0x90,
+				0x81,
+				0x13,
+				0xB5,
+				0x3A,
+				0x41,
+				0x79,
+				0x92
+			};
+
+			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_ID2D1TransformGraph));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::GetInputCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, uint>)(lpVtbl[3]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::SetSingleTransformNode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetSingleTransformNode(ID2D1TransformNode* node)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, ID2D1TransformNode*, int>)(lpVtbl[4]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), node);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::AddNode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult AddNode(ID2D1TransformNode* node)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, ID2D1TransformNode*, int>)(lpVtbl[5]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), node);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::RemoveNode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult RemoveNode(ID2D1TransformNode* node)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, ID2D1TransformNode*, int>)(lpVtbl[6]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), node);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::SetOutputNode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetOutputNode(ID2D1TransformNode* node)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, ID2D1TransformNode*, int>)(lpVtbl[7]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), node);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::ConnectNode"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult ConnectNode(ID2D1TransformNode* fromNode, ID2D1TransformNode* toNode, uint toNodeInputIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, ID2D1TransformNode*, ID2D1TransformNode*, uint, int>)(lpVtbl[8]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), fromNode, toNode, toNodeInputIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::ConnectToEffectInput"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult ConnectToEffectInput(uint toEffectInputIndex, ID2D1TransformNode* node, uint toNodeInputIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, uint, ID2D1TransformNode*, uint, int>)(lpVtbl[9]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), toEffectInputIndex, node, toNodeInputIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::Clear"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void Clear()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, void>)(lpVtbl[10]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformGraph::SetPassthroughGraph"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetPassthroughGraph(uint effectInputIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1TransformGraph*, uint, int>)(lpVtbl[11]))((ID2D1TransformGraph*)Unsafe.AsPointer(ref this), effectInputIndex);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Transform"]/*' />
+/// <unmanaged>ID2D1Transform</unmanaged>
+[Guid("ef1a287d-342a-4f76-8fdb-da0d6ea9f92b")]
+[NativeTypeName("struct ID2D1Transform : ID2D1TransformNode")]
+[NativeInheritance("ID2D1TransformNode")]
+public unsafe partial struct ID2D1Transform
+{
+	public static ref readonly Guid IID_ID2D1Transform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x7D, 0x28, 0x1A, 0xEF,
+				0x2A, 0x34,
+				0x76, 0x4F,
+				0x8F,
+				0xDB,
+				0xDA,
+				0x0D,
+				0x6E,
+				0xA9,
+				0xF9,
+				0x2B
+			};
+
+			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_ID2D1Transform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Transform*, uint>)(lpVtbl[3]))((ID2D1Transform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Transform::MapOutputRectToInputRects"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Transform*, RawRect*, RawRect*, uint, int>)(lpVtbl[4]))((ID2D1Transform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Transform::MapInputRectsToOutputRect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult MapInputRectsToOutputRect(RawRect* inputRects, RawRect* inputOpaqueSubRects, uint inputRectCount, RawRect* outputRect, RawRect* outputOpaqueSubRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Transform*, RawRect*, RawRect*, uint, RawRect*, RawRect*, int>)(lpVtbl[5]))((ID2D1Transform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Transform::MapInvalidRect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Transform*, uint, RawRect*, RawRect*, int>)(lpVtbl[6]))((ID2D1Transform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawTransform"]/*' />
+/// <unmanaged>ID2D1DrawTransform</unmanaged>
+[Guid("36bfdcb6-9739-435d-a30d-a653beff6a6f")]
+[NativeTypeName("struct ID2D1DrawTransform : ID2D1Transform")]
+[NativeInheritance("ID2D1Transform")]
+public unsafe partial struct ID2D1DrawTransform
+{
+	public static ref readonly Guid IID_ID2D1DrawTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xB6, 0xDC, 0xBF, 0x36,
+				0x39, 0x97,
+				0x5D, 0x43,
+				0xA3,
+				0x0D,
+				0xA6,
+				0x53,
+				0xBE,
+				0xFF,
+				0x6A,
+				0x6F
+			};
+
+			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_ID2D1DrawTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapOutputRectToInputRects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, RawRect*, RawRect*, uint, int>)(lpVtbl[3]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapInputRectsToOutputRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult MapInputRectsToOutputRect(RawRect* inputRects, RawRect* inputOpaqueSubRects, uint inputRectCount, RawRect* outputRect, RawRect* outputOpaqueSubRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, RawRect*, RawRect*, uint, RawRect*, RawRect*, int>)(lpVtbl[4]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapInvalidRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, uint, RawRect*, RawRect*, int>)(lpVtbl[5]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, uint>)(lpVtbl[6]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DrawTransform::SetDrawInfo"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetDrawInfo(ID2D1DrawInfo* drawInfo)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, ID2D1DrawInfo*, int>)(lpVtbl[7]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), drawInfo);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeTransform"]/*' />
+/// <unmanaged>ID2D1ComputeTransform</unmanaged>
+[Guid("0d85573c-01e3-4f7d-bfd9-0d60608bf3c3")]
+[NativeTypeName("struct ID2D1ComputeTransform : ID2D1Transform")]
+[NativeInheritance("ID2D1Transform")]
+public unsafe partial struct ID2D1ComputeTransform
+{
+	public static ref readonly Guid IID_ID2D1ComputeTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x3C, 0x57, 0x85, 0x0D,
+				0xE3, 0x01,
+				0x7D, 0x4F,
+				0xBF,
+				0xD9,
+				0x0D,
+				0x60,
+				0x60,
+				0x8B,
+				0xF3,
+				0xC3
+			};
+
+			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_ID2D1ComputeTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapOutputRectToInputRects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, RawRect*, RawRect*, uint, int>)(lpVtbl[3]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapInputRectsToOutputRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult MapInputRectsToOutputRect(RawRect* inputRects, RawRect* inputOpaqueSubRects, uint inputRectCount, RawRect* outputRect, RawRect* outputOpaqueSubRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, RawRect*, RawRect*, uint, RawRect*, RawRect*, int>)(lpVtbl[4]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapInvalidRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, uint, RawRect*, RawRect*, int>)(lpVtbl[5]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, uint>)(lpVtbl[6]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeTransform::SetComputeInfo"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetComputeInfo(ID2D1ComputeInfo* computeInfo)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, ID2D1ComputeInfo*, int>)(lpVtbl[7]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), computeInfo);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ComputeTransform::CalculateThreadgroups"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CalculateThreadgroups(RawRect* outputRect, uint* dimensionX, uint* dimensionY, uint* dimensionZ)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, RawRect*, uint*, uint*, uint*, int>)(lpVtbl[8]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), outputRect, dimensionX, dimensionY, dimensionZ);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1AnalysisTransform"]/*' />
+/// <unmanaged>ID2D1AnalysisTransform</unmanaged>
+[Guid("0359dc30-95e6-4568-9055-27720d130e93")]
+[NativeTypeName("struct ID2D1AnalysisTransform : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1AnalysisTransform
+{
+	public static ref readonly Guid IID_ID2D1AnalysisTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x30, 0xDC, 0x59, 0x03,
+				0xE6, 0x95,
+				0x68, 0x45,
+				0x90,
+				0x55,
+				0x27,
+				0x72,
+				0x0D,
+				0x13,
+				0x0E,
+				0x93
+			};
+
+			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_ID2D1AnalysisTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1AnalysisTransform::ProcessAnalysisResults"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult ProcessAnalysisResults(byte* analysisData, uint analysisDataCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1AnalysisTransform*, byte*, uint, int>)(lpVtbl[3]))((ID2D1AnalysisTransform*)Unsafe.AsPointer(ref this), analysisData, analysisDataCount);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SourceTransform"]/*' />
+/// <unmanaged>ID2D1SourceTransform</unmanaged>
+[Guid("db1800dd-0c34-4cf9-be90-31cc0a5653e1")]
+[NativeTypeName("struct ID2D1SourceTransform : ID2D1Transform")]
+[NativeInheritance("ID2D1Transform")]
+public unsafe partial struct ID2D1SourceTransform
+{
+	public static ref readonly Guid IID_ID2D1SourceTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xDD, 0x00, 0x18, 0xDB,
+				0x34, 0x0C,
+				0xF9, 0x4C,
+				0xBE,
+				0x90,
+				0x31,
+				0xCC,
+				0x0A,
+				0x56,
+				0x53,
+				0xE1
+			};
+
+			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_ID2D1SourceTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapOutputRectToInputRects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, RawRect*, RawRect*, uint, int>)(lpVtbl[3]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapInputRectsToOutputRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult MapInputRectsToOutputRect(RawRect* inputRects, RawRect* inputOpaqueSubRects, uint inputRectCount, RawRect* outputRect, RawRect* outputOpaqueSubRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, RawRect*, RawRect*, uint, RawRect*, RawRect*, int>)(lpVtbl[4]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
+	}
+
+	/// <inheritdoc cref="ID2D1Transform.MapInvalidRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, uint, RawRect*, RawRect*, int>)(lpVtbl[5]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, uint>)(lpVtbl[6]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SourceTransform::SetRenderInfo"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetRenderInfo(ID2D1RenderInfo* renderInfo)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, ID2D1RenderInfo*, int>)(lpVtbl[7]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), renderInfo);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SourceTransform::Draw"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult Draw(ID2D1Bitmap1* target, RawRect* drawRect, Common.Point2u* targetOrigin)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, ID2D1Bitmap1*, RawRect*, Common.Point2u*, int>)(lpVtbl[8]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), target, drawRect, targetOrigin);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ConcreteTransform"]/*' />
+/// <unmanaged>ID2D1ConcreteTransform</unmanaged>
+[Guid("1a799d8a-69f7-4e4c-9fed-437ccc6684cc")]
+[NativeTypeName("struct ID2D1ConcreteTransform : ID2D1TransformNode")]
+[NativeInheritance("ID2D1TransformNode")]
+public unsafe partial struct ID2D1ConcreteTransform
+{
+	public static ref readonly Guid IID_ID2D1ConcreteTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x8A, 0x9D, 0x79, 0x1A,
+				0xF7, 0x69,
+				0x4C, 0x4E,
+				0x9F,
+				0xED,
+				0x43,
+				0x7C,
+				0xCC,
+				0x66,
+				0x84,
+				0xCC
+			};
+
+			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_ID2D1ConcreteTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ConcreteTransform*, uint>)(lpVtbl[3]))((ID2D1ConcreteTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ConcreteTransform::SetOutputBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ConcreteTransform*, BufferPrecision, ChannelDepth, int>)(lpVtbl[4]))((ID2D1ConcreteTransform*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ConcreteTransform::SetCached"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetCached(Bool32 isCached)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ConcreteTransform*, Bool32, void>)(lpVtbl[5]))((ID2D1ConcreteTransform*)Unsafe.AsPointer(ref this), isCached);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BlendTransform"]/*' />
+/// <unmanaged>ID2D1BlendTransform</unmanaged>
+[Guid("63ac0b32-ba44-450f-8806-7f4ca1ff2f1b")]
+[NativeTypeName("struct ID2D1BlendTransform : ID2D1ConcreteTransform")]
+[NativeInheritance("ID2D1ConcreteTransform")]
+public unsafe partial struct ID2D1BlendTransform
+{
+	public static ref readonly Guid IID_ID2D1BlendTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x32, 0x0B, 0xAC, 0x63,
+				0x44, 0xBA,
+				0x0F, 0x45,
+				0x88,
+				0x06,
+				0x7F,
+				0x4C,
+				0xA1,
+				0xFF,
+				0x2F,
+				0x1B
+			};
+
+			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_ID2D1BlendTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ConcreteTransform.SetOutputBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, BufferPrecision, ChannelDepth, int>)(lpVtbl[3]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
+	}
+
+	/// <inheritdoc cref="ID2D1ConcreteTransform.SetCached" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetCached(Bool32 isCached)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, Bool32, void>)(lpVtbl[4]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this), isCached);
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, uint>)(lpVtbl[5]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BlendTransform::SetDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetDescription(BlendDescription* description)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, BlendDescription*, void>)(lpVtbl[6]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this), description);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BlendTransform::GetDescription"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetDescription(BlendDescription* description)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, BlendDescription*, void>)(lpVtbl[7]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this), description);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BorderTransform"]/*' />
+/// <unmanaged>ID2D1BorderTransform</unmanaged>
+[Guid("4998735c-3a19-473c-9781-656847e3a347")]
+[NativeTypeName("struct ID2D1BorderTransform : ID2D1ConcreteTransform")]
+[NativeInheritance("ID2D1ConcreteTransform")]
+public unsafe partial struct ID2D1BorderTransform
+{
+	public static ref readonly Guid IID_ID2D1BorderTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x5C, 0x73, 0x98, 0x49,
+				0x19, 0x3A,
+				0x3C, 0x47,
+				0x97,
+				0x81,
+				0x65,
+				0x68,
+				0x47,
+				0xE3,
+				0xA3,
+				0x47
+			};
+
+			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_ID2D1BorderTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ConcreteTransform.SetOutputBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, BufferPrecision, ChannelDepth, int>)(lpVtbl[3]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
+	}
+
+	/// <inheritdoc cref="ID2D1ConcreteTransform.SetCached" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetCached(Bool32 isCached)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, Bool32, void>)(lpVtbl[4]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this), isCached);
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, uint>)(lpVtbl[5]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BorderTransform::SetExtendModeX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetExtendModeX(ExtendMode extendMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, ExtendMode, void>)(lpVtbl[6]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this), extendMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BorderTransform::SetExtendModeY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void SetExtendModeY(ExtendMode extendMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, ExtendMode, void>)(lpVtbl[7]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this), extendMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BorderTransform::GetExtendModeX"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeX()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, Graphics.Direct2D.ExtendMode>)(lpVtbl[8]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BorderTransform::GetExtendModeY"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public Graphics.Direct2D.ExtendMode GetExtendModeY()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, Graphics.Direct2D.ExtendMode>)(lpVtbl[9]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1OffsetTransform"]/*' />
+/// <unmanaged>ID2D1OffsetTransform</unmanaged>
+[Guid("3fe6adea-7643-4f53-bd14-a0ce63f24042")]
+[NativeTypeName("struct ID2D1OffsetTransform : ID2D1TransformNode")]
+[NativeInheritance("ID2D1TransformNode")]
+public unsafe partial struct ID2D1OffsetTransform
+{
+	public static ref readonly Guid IID_ID2D1OffsetTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xEA, 0xAD, 0xE6, 0x3F,
+				0x43, 0x76,
+				0x53, 0x4F,
+				0xBD,
+				0x14,
+				0xA0,
+				0xCE,
+				0x63,
+				0xF2,
+				0x40,
+				0x42
+			};
+
+			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_ID2D1OffsetTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1OffsetTransform*, uint>)(lpVtbl[3]))((ID2D1OffsetTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1OffsetTransform::SetOffset"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetOffset(System.Drawing.Point* offset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1OffsetTransform*, System.Drawing.Point*, void>)(lpVtbl[4]))((ID2D1OffsetTransform*)Unsafe.AsPointer(ref this), offset);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1OffsetTransform::GetOffset"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public System.Drawing.Point GetOffset()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1OffsetTransform*, System.Drawing.Point>)(lpVtbl[5]))((ID2D1OffsetTransform*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BoundsAdjustmentTransform"]/*' />
+/// <unmanaged>ID2D1BoundsAdjustmentTransform</unmanaged>
+[Guid("90f732e2-5092-4606-a819-8651970baccd")]
+[NativeTypeName("struct ID2D1BoundsAdjustmentTransform : ID2D1TransformNode")]
+[NativeInheritance("ID2D1TransformNode")]
+public unsafe partial struct ID2D1BoundsAdjustmentTransform
+{
+	public static ref readonly Guid IID_ID2D1BoundsAdjustmentTransform
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE2, 0x32, 0xF7, 0x90,
+				0x92, 0x50,
+				0x06, 0x46,
+				0xA8,
+				0x19,
+				0x86,
+				0x51,
+				0x97,
+				0x0B,
+				0xAC,
+				0xCD
+			};
+
+			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_ID2D1BoundsAdjustmentTransform));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1TransformNode.GetInputCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetInputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1BoundsAdjustmentTransform*, uint>)(lpVtbl[3]))((ID2D1BoundsAdjustmentTransform*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BoundsAdjustmentTransform::SetOutputBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetOutputBounds(RawRect* outputBounds)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BoundsAdjustmentTransform*, RawRect*, void>)(lpVtbl[4]))((ID2D1BoundsAdjustmentTransform*)Unsafe.AsPointer(ref this), outputBounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1BoundsAdjustmentTransform::GetOutputBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetOutputBounds(RawRect* outputBounds)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1BoundsAdjustmentTransform*, RawRect*, void>)(lpVtbl[5]))((ID2D1BoundsAdjustmentTransform*)Unsafe.AsPointer(ref this), outputBounds);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectImpl"]/*' />
+/// <unmanaged>ID2D1EffectImpl</unmanaged>
+[Guid("a248fd3f-3e6c-4e63-9f03-7f68ecc91db9")]
+[NativeTypeName("struct ID2D1EffectImpl : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1EffectImpl
+{
+	public static ref readonly Guid IID_ID2D1EffectImpl
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x3F, 0xFD, 0x48, 0xA2,
+				0x6C, 0x3E,
+				0x63, 0x4E,
+				0x9F,
+				0x03,
+				0x7F,
+				0x68,
+				0xEC,
+				0xC9,
+				0x1D,
+				0xB9
+			};
+
+			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_ID2D1EffectImpl));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectImpl::Initialize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Initialize(ID2D1EffectContext* effectContext, ID2D1TransformGraph* transformGraph)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectImpl*, ID2D1EffectContext*, ID2D1TransformGraph*, int>)(lpVtbl[3]))((ID2D1EffectImpl*)Unsafe.AsPointer(ref this), effectContext, transformGraph);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectImpl::PrepareForRender"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult PrepareForRender(ChangeType changeType)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectImpl*, ChangeType, int>)(lpVtbl[4]))((ID2D1EffectImpl*)Unsafe.AsPointer(ref this), changeType);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectImpl::SetGraph"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult SetGraph(ID2D1TransformGraph* transformGraph)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectImpl*, ID2D1TransformGraph*, int>)(lpVtbl[5]))((ID2D1EffectImpl*)Unsafe.AsPointer(ref this), transformGraph);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext"]/*' />
+/// <unmanaged>ID2D1EffectContext</unmanaged>
+[Guid("3d9f916b-27dc-4ad7-b4f1-64945340f563")]
+[NativeTypeName("struct ID2D1EffectContext : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct ID2D1EffectContext
+{
+	public static ref readonly Guid IID_ID2D1EffectContext
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x6B, 0x91, 0x9F, 0x3D,
+				0xDC, 0x27,
+				0xD7, 0x4A,
+				0xB4,
+				0xF1,
+				0x64,
+				0x94,
+				0x53,
+				0x40,
+				0xF5,
+				0x63
+			};
+
+			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_ID2D1EffectContext));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::GetDpi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, float*, float*, void>)(lpVtbl[3]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateEffect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, ID2D1Effect**, int>)(lpVtbl[4]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::GetMaximumSupportedFeatureLevel"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetMaximumSupportedFeatureLevel(Graphics.Direct3D.FeatureLevel* featureLevels, uint featureLevelsCount, Graphics.Direct3D.FeatureLevel* maximumSupportedFeatureLevel)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Graphics.Direct3D.FeatureLevel*, uint, Graphics.Direct3D.FeatureLevel*, int>)(lpVtbl[5]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), featureLevels, featureLevelsCount, maximumSupportedFeatureLevel);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateTransformNodeFromEffect"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateTransformNodeFromEffect(ID2D1Effect* effect, ID2D1TransformNode** transformNode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, ID2D1Effect*, ID2D1TransformNode**, int>)(lpVtbl[6]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), effect, transformNode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateBlendTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateBlendTransform(uint numInputs, BlendDescription* blendDescription, ID2D1BlendTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, uint, BlendDescription*, ID2D1BlendTransform**, int>)(lpVtbl[7]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), numInputs, blendDescription, transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateBorderTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateBorderTransform(ExtendMode extendModeX, ExtendMode extendModeY, ID2D1BorderTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, ExtendMode, ExtendMode, ID2D1BorderTransform**, int>)(lpVtbl[8]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), extendModeX, extendModeY, transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateOffsetTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateOffsetTransform(System.Drawing.Point* offset, ID2D1OffsetTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, System.Drawing.Point*, ID2D1OffsetTransform**, int>)(lpVtbl[9]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), offset, transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateBoundsAdjustmentTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateBoundsAdjustmentTransform(RawRect* outputRectangle, ID2D1BoundsAdjustmentTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, RawRect*, ID2D1BoundsAdjustmentTransform**, int>)(lpVtbl[10]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), outputRectangle, transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::LoadPixelShader"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult LoadPixelShader(Guid* shaderId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, byte*, uint, int>)(lpVtbl[11]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), shaderId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::LoadVertexShader"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult LoadVertexShader(Guid* resourceId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, byte*, uint, int>)(lpVtbl[12]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), resourceId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::LoadComputeShader"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult LoadComputeShader(Guid* resourceId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, byte*, uint, int>)(lpVtbl[13]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), resourceId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::IsShaderLoaded"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public Bool32 IsShaderLoaded(Guid* shaderId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, Bool32>)(lpVtbl[14]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), shaderId);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateResourceTexture"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateResourceTexture(Guid* resourceId, ResourceTextureProperties* resourceTextureProperties, byte* data, uint* strides, uint dataSize, ID2D1ResourceTexture** resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, ResourceTextureProperties*, byte*, uint*, uint, ID2D1ResourceTexture**, int>)(lpVtbl[15]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), resourceId, resourceTextureProperties, data, strides, dataSize, resourceTexture);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::FindResourceTexture"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult FindResourceTexture(Guid* resourceId, ID2D1ResourceTexture** resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, ID2D1ResourceTexture**, int>)(lpVtbl[16]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), resourceId, resourceTexture);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateVertexBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateVertexBuffer(VertexBufferProperties* vertexBufferProperties, Guid* resourceId, CustomVertexBufferProperties* customVertexBufferProperties, ID2D1VertexBuffer** buffer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, VertexBufferProperties*, Guid*, CustomVertexBufferProperties*, ID2D1VertexBuffer**, int>)(lpVtbl[17]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), vertexBufferProperties, resourceId, customVertexBufferProperties, buffer);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::FindVertexBuffer"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult FindVertexBuffer(Guid* resourceId, ID2D1VertexBuffer** buffer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Guid*, ID2D1VertexBuffer**, int>)(lpVtbl[18]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), resourceId, buffer);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateColorContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[19]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateColorContextFromFilename"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[20]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CreateColorContextFromWicColorContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[21]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::CheckFeatureSupport"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CheckFeatureSupport(Feature feature, void* featureSupportData, uint featureSupportDataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, Feature, void*, uint, int>)(lpVtbl[22]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), feature, featureSupportData, featureSupportDataSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext::IsBufferPrecisionSupported"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext*, BufferPrecision, Bool32>)(lpVtbl[23]))((ID2D1EffectContext*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GeometryRealization"]/*' />
+/// <unmanaged>ID2D1GeometryRealization</unmanaged>
+[Guid("a16907d7-bc02-4801-99e8-8cf7f485f774")]
+[NativeTypeName("struct ID2D1GeometryRealization : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1GeometryRealization
+{
+	public static ref readonly Guid IID_ID2D1GeometryRealization
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD7, 0x07, 0x69, 0xA1,
+				0x02, 0xBC,
+				0x01, 0x48,
+				0x99,
+				0xE8,
+				0x8C,
+				0xF7,
+				0xF4,
+				0x85,
+				0xF7,
+				0x74
+			};
+
+			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_ID2D1GeometryRealization));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GeometryRealization*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GeometryRealization*)Unsafe.AsPointer(ref this), factory);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext1"]/*' />
+/// <unmanaged>ID2D1DeviceContext1</unmanaged>
+[Guid("d37f57e4-6908-459f-a199-e72f24f79987")]
+[NativeTypeName("struct ID2D1DeviceContext1 : ID2D1DeviceContext")]
+[NativeInheritance("ID2D1DeviceContext")]
+public unsafe partial struct ID2D1DeviceContext1
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE4, 0x57, 0x7F, 0xD3,
+				0x08, 0x69,
+				0x9F, 0x45,
+				0xA1,
+				0x99,
+				0xE7,
+				0x2F,
+				0x24,
+				0xF7,
+				0x99,
+				0x87
+			};
+
+			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_ID2D1DeviceContext1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[3]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[4]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[5]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[6]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[7]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[8]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Guid*, ID2D1Effect**, int>)(lpVtbl[9]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[10]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[11]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[12]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1CommandList**, int>)(lpVtbl[13]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[14]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, BufferPrecision, Bool32>)(lpVtbl[15]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[16]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[17]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetGlyphRunWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[18]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Device**, void>)(lpVtbl[19]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, void>)(lpVtbl[20]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image**, void>)(lpVtbl[21]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RenderingControls*, void>)(lpVtbl[22]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RenderingControls*, void>)(lpVtbl[23]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, PrimitiveBlend, void>)(lpVtbl[24]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[25]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, UnitMode, void>)(lpVtbl[26]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Direct2D.UnitMode>)(lpVtbl[27]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[28]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[29]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[30]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[31]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[32]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[33]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, uint*, int>)(lpVtbl[34]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[35]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectRequiredInputRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[36]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[37]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[38]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[39]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[40]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[41]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[42]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[43]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[44]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[45]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[46]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[47]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Mesh**, int>)(lpVtbl[48]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[49]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[50]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[51]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[52]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[53]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[54]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[55]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[56]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[57]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[58]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[59]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[60]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[61]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[62]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[63]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Matrix3x2*, void>)(lpVtbl[64]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Matrix3x2**, void>)(lpVtbl[65]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, AntialiasMode, void>)(lpVtbl[66]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[67]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, TextAntialiasMode, void>)(lpVtbl[68]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[69]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[70]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[71]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong, ulong, void>)(lpVtbl[72]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong*, ulong*, void>)(lpVtbl[73]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[74]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, void>)(lpVtbl[75]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong*, ulong*, int>)(lpVtbl[76]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1DrawingStateBlock*, void>)(lpVtbl[77]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1DrawingStateBlock*, void>)(lpVtbl[78]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.RectF*, AntialiasMode, void>)(lpVtbl[79]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, void>)(lpVtbl[80]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.ColorF*, void>)(lpVtbl[81]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, void>)(lpVtbl[82]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong*, ulong*, int>)(lpVtbl[83]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[84]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, float, float, void>)(lpVtbl[85]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, float*, float*, void>)(lpVtbl[86]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.SizeF>)(lpVtbl[87]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[88]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, uint>)(lpVtbl[89]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RenderTargetProperties*, Bool32>)(lpVtbl[90]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Factory**, void>)(lpVtbl[91]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext1::CreateFilledGeometryRealization"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(92)]
+	public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[92]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext1::CreateStrokedGeometryRealization"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(93)]
+	public HResult CreateStrokedGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, float strokeWidth, ID2D1StrokeStyle* strokeStyle, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Geometry*, float, float, ID2D1StrokeStyle*, ID2D1GeometryRealization**, int>)(lpVtbl[93]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext1::DrawGeometryRealization"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(94)]
+	public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[94]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometryRealization, brush);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device1"]/*' />
+/// <unmanaged>ID2D1Device1</unmanaged>
+[Guid("d21768e1-23a4-4823-a14b-7c3eba85d658")]
+[NativeTypeName("struct ID2D1Device1 : ID2D1Device")]
+[NativeInheritance("ID2D1Device")]
+public unsafe partial struct ID2D1Device1
+{
+	public static ref readonly Guid IID_ID2D1Device1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE1, 0x68, 0x17, 0xD2,
+				0xA4, 0x23,
+				0x23, 0x48,
+				0xA1,
+				0x4B,
+				0x7C,
+				0x3E,
+				0xBA,
+				0x85,
+				0xD6,
+				0x58
+			};
+
+			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_ID2D1Device1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[3]))((ID2D1Device1*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device1*, ulong, void>)(lpVtbl[4]))((ID2D1Device1*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, ulong>)(lpVtbl[5]))((ID2D1Device1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.ClearResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device1*, uint, void>)(lpVtbl[6]))((ID2D1Device1*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device1*, ID2D1Factory**, void>)(lpVtbl[7]))((ID2D1Device1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device1::GetRenderingPriority"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public Graphics.Direct2D.RenderingPriority GetRenderingPriority()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, Graphics.Direct2D.RenderingPriority>)(lpVtbl[8]))((ID2D1Device1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device1::SetRenderingPriority"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void SetRenderingPriority(RenderingPriority renderingPriority)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device1*, RenderingPriority, void>)(lpVtbl[9]))((ID2D1Device1*)Unsafe.AsPointer(ref this), renderingPriority);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device1::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[10]))((ID2D1Device1*)Unsafe.AsPointer(ref this), options, deviceContext1);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory2"]/*' />
+/// <unmanaged>ID2D1Factory2</unmanaged>
+[Guid("94f81a73-9212-4376-9c58-b16a3a0d3992")]
+[NativeTypeName("struct ID2D1Factory2 : ID2D1Factory1")]
+[NativeInheritance("ID2D1Factory1")]
+public unsafe partial struct ID2D1Factory2
+{
+	public static ref readonly Guid IID_ID2D1Factory2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x73, 0x1A, 0xF8, 0x94,
+				0x12, 0x92,
+				0x76, 0x43,
+				0x9C,
+				0x58,
+				0xB1,
+				0x6A,
+				0x3A,
+				0x0D,
+				0x39,
+				0x92
+			};
+
+			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_ID2D1Factory2));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[3]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[4]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, ID2D1PathGeometry1**, int>)(lpVtbl[5]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[6]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[7]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[8]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromString" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[9]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, int>)(lpVtbl[10]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, uint, uint*, uint*, int>)(lpVtbl[11]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, ID2D1Properties**, int>)(lpVtbl[12]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, int>)(lpVtbl[13]))((ID2D1Factory2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory2*, float*, float*, void>)(lpVtbl[14]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[15]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[16]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[17]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[18]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[19]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, ID2D1PathGeometry**, int>)(lpVtbl[20]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[21]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[22]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[23]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[24]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[25]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[26]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory2::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[27]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink1"]/*' />
+/// <unmanaged>ID2D1CommandSink1</unmanaged>
+[Guid("9eb767fd-4269-4467-b8c2-eb30cb305743")]
+[NativeTypeName("struct ID2D1CommandSink1 : ID2D1CommandSink")]
+[NativeInheritance("ID2D1CommandSink")]
+public unsafe partial struct ID2D1CommandSink1
+{
+	public static ref readonly Guid IID_ID2D1CommandSink1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xFD, 0x67, 0xB7, 0x9E,
+				0x69, 0x42,
+				0x67, 0x44,
+				0xB8,
+				0xC2,
+				0xEB,
+				0x30,
+				0xCB,
+				0x30,
+				0x57,
+				0x43
+			};
+
+			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_ID2D1CommandSink1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult BeginDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, int>)(lpVtbl[3]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult EndDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, int>)(lpVtbl[4]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, AntialiasMode, int>)(lpVtbl[5]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetTags(ulong tag1, ulong tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ulong, ulong, int>)(lpVtbl[6]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, TextAntialiasMode, int>)(lpVtbl[7]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[8]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetTransform(Matrix3x2* transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, Matrix3x2*, int>)(lpVtbl[9]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, PrimitiveBlend, int>)(lpVtbl[10]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetUnitMode(UnitMode unitMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, UnitMode, int>)(lpVtbl[11]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult Clear(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, Common.ColorF*, int>)(lpVtbl[12]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[13]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[14]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[17]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[18]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[19]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[20]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[21]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[22]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, Common.RectF*, AntialiasMode, int>)(lpVtbl[24]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult PushLayer(LayerParameters1* layerParameters1, ID2D1Layer* layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[25]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), layerParameters1, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult PopAxisAlignedClip()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, int>)(lpVtbl[26]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult PopLayer()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, int>)(lpVtbl[27]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink1::SetPrimitiveBlend1"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink1*, PrimitiveBlend, int>)(lpVtbl[28]))((ID2D1CommandSink1*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgAttribute"]/*' />
+/// <unmanaged>ID2D1SvgAttribute</unmanaged>
+[Guid("c9cdb0dd-f8c9-4e70-b7c2-301c80292c5e")]
+[NativeTypeName("struct ID2D1SvgAttribute : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1SvgAttribute
+{
+	public static ref readonly Guid IID_ID2D1SvgAttribute
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xDD, 0xB0, 0xCD, 0xC9,
+				0xC9, 0xF8,
+				0x70, 0x4E,
+				0xB7,
+				0xC2,
+				0x30,
+				0x1C,
+				0x80,
+				0x29,
+				0x2C,
+				0x5E
+			};
+
+			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_ID2D1SvgAttribute));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgAttribute*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1SvgAttribute*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgAttribute::GetElement"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetElement(ID2D1SvgElement** element)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgAttribute*, ID2D1SvgElement**, void>)(lpVtbl[4]))((ID2D1SvgAttribute*)Unsafe.AsPointer(ref this), element);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgAttribute::Clone"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult Clone(ID2D1SvgAttribute** attribute)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgAttribute*, ID2D1SvgAttribute**, int>)(lpVtbl[5]))((ID2D1SvgAttribute*)Unsafe.AsPointer(ref this), attribute);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint"]/*' />
+/// <unmanaged>ID2D1SvgPaint</unmanaged>
+[Guid("d59bab0a-68a2-455b-a5dc-9eb2854e2490")]
+[NativeTypeName("struct ID2D1SvgPaint : ID2D1SvgAttribute")]
+[NativeInheritance("ID2D1SvgAttribute")]
+public unsafe partial struct ID2D1SvgPaint
+{
+	public static ref readonly Guid IID_ID2D1SvgPaint
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x0A, 0xAB, 0x9B, 0xD5,
+				0xA2, 0x68,
+				0x5B, 0x45,
+				0xA5,
+				0xDC,
+				0x9E,
+				0xB2,
+				0x85,
+				0x4E,
+				0x24,
+				0x90
+			};
+
+			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_ID2D1SvgPaint));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.GetElement" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetElement(ID2D1SvgElement** element)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, ID2D1SvgElement**, void>)(lpVtbl[3]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), element);
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.Clone" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Clone(ID2D1SvgAttribute** attribute)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, ID2D1SvgAttribute**, int>)(lpVtbl[4]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), attribute);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, ID2D1Factory**, void>)(lpVtbl[5]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::SetPaintType"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetPaintType(SvgPaintType paintType)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, SvgPaintType, int>)(lpVtbl[6]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), paintType);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::GetPaintType"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.SvgPaintType GetPaintType()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, Graphics.Direct2D.SvgPaintType>)(lpVtbl[7]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::SetColor"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetColor(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, Common.ColorF*, int>)(lpVtbl[8]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::GetColor"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void GetColor(Common.ColorF* color)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, Common.ColorF*, void>)(lpVtbl[9]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::SetId"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetId(ushort* id)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, ushort*, int>)(lpVtbl[10]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), id);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::GetId"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetId(ushort* id, uint idCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, ushort*, uint, int>)(lpVtbl[11]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this), id, idCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPaint::GetIdLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public uint GetIdLength()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPaint*, uint>)(lpVtbl[12]))((ID2D1SvgPaint*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray"]/*' />
+/// <unmanaged>ID2D1SvgStrokeDashArray</unmanaged>
+[Guid("f1c0ca52-92a3-4f00-b4ce-f35691efd9d9")]
+[NativeTypeName("struct ID2D1SvgStrokeDashArray : ID2D1SvgAttribute")]
+[NativeInheritance("ID2D1SvgAttribute")]
+public unsafe partial struct ID2D1SvgStrokeDashArray
+{
+	public static ref readonly Guid IID_ID2D1SvgStrokeDashArray
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x52, 0xCA, 0xC0, 0xF1,
+				0xA3, 0x92,
+				0x00, 0x4F,
+				0xB4,
+				0xCE,
+				0xF3,
+				0x56,
+				0x91,
+				0xEF,
+				0xD9,
+				0xD9
+			};
+
+			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_ID2D1SvgStrokeDashArray));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.GetElement" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetElement(ID2D1SvgElement** element)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, ID2D1SvgElement**, void>)(lpVtbl[3]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), element);
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.Clone" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Clone(ID2D1SvgAttribute** attribute)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, ID2D1SvgAttribute**, int>)(lpVtbl[4]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), attribute);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, ID2D1Factory**, void>)(lpVtbl[5]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray::RemoveDashesAtEnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult RemoveDashesAtEnd(uint dashesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, uint, int>)(lpVtbl[6]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), dashesCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray::UpdateDashes"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult UpdateDashes(SvgLength* dashes, uint dashesCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, SvgLength*, uint, uint, int>)(lpVtbl[7]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), dashes, dashesCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray::UpdateDashes"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult UpdateDashes(float* dashes, uint dashesCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, float*, uint, uint, int>)(lpVtbl[8]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), dashes, dashesCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray::GetDashes"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult GetDashes(SvgLength* dashes, uint dashesCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, SvgLength*, uint, uint, int>)(lpVtbl[9]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), dashes, dashesCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray::GetDashes"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult GetDashes(float* dashes, uint dashesCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, float*, uint, uint, int>)(lpVtbl[10]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this), dashes, dashesCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgStrokeDashArray::GetDashesCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public uint GetDashesCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgStrokeDashArray*, uint>)(lpVtbl[11]))((ID2D1SvgStrokeDashArray*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPointCollection"]/*' />
+/// <unmanaged>ID2D1SvgPointCollection</unmanaged>
+[Guid("9dbe4c0d-3572-4dd9-9825-5530813bb712")]
+[NativeTypeName("struct ID2D1SvgPointCollection : ID2D1SvgAttribute")]
+[NativeInheritance("ID2D1SvgAttribute")]
+public unsafe partial struct ID2D1SvgPointCollection
+{
+	public static ref readonly Guid IID_ID2D1SvgPointCollection
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x0D, 0x4C, 0xBE, 0x9D,
+				0x72, 0x35,
+				0xD9, 0x4D,
+				0x98,
+				0x25,
+				0x55,
+				0x30,
+				0x81,
+				0x3B,
+				0xB7,
+				0x12
+			};
+
+			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_ID2D1SvgPointCollection));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.GetElement" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetElement(ID2D1SvgElement** element)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, ID2D1SvgElement**, void>)(lpVtbl[3]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this), element);
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.Clone" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Clone(ID2D1SvgAttribute** attribute)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, ID2D1SvgAttribute**, int>)(lpVtbl[4]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this), attribute);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, ID2D1Factory**, void>)(lpVtbl[5]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPointCollection::RemovePointsAtEnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult RemovePointsAtEnd(uint pointsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, uint, int>)(lpVtbl[6]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this), pointsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPointCollection::UpdatePoints"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult UpdatePoints(System.Drawing.PointF** points, uint pointsCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, System.Drawing.PointF**, uint, uint, int>)(lpVtbl[7]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this), points, pointsCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPointCollection::GetPoints"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult GetPoints(System.Drawing.PointF** points, uint pointsCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, System.Drawing.PointF**, uint, uint, int>)(lpVtbl[8]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this), points, pointsCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPointCollection::GetPointsCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public uint GetPointsCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPointCollection*, uint>)(lpVtbl[9]))((ID2D1SvgPointCollection*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData"]/*' />
+/// <unmanaged>ID2D1SvgPathData</unmanaged>
+[Guid("c095e4f4-bb98-43d6-9745-4d1b84ec9888")]
+[NativeTypeName("struct ID2D1SvgPathData : ID2D1SvgAttribute")]
+[NativeInheritance("ID2D1SvgAttribute")]
+public unsafe partial struct ID2D1SvgPathData
+{
+	public static ref readonly Guid IID_ID2D1SvgPathData
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xF4, 0xE4, 0x95, 0xC0,
+				0x98, 0xBB,
+				0xD6, 0x43,
+				0x97,
+				0x45,
+				0x4D,
+				0x1B,
+				0x84,
+				0xEC,
+				0x98,
+				0x88
+			};
+
+			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_ID2D1SvgPathData));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.GetElement" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetElement(ID2D1SvgElement** element)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, ID2D1SvgElement**, void>)(lpVtbl[3]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), element);
+	}
+
+	/// <inheritdoc cref="ID2D1SvgAttribute.Clone" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult Clone(ID2D1SvgAttribute** attribute)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, ID2D1SvgAttribute**, int>)(lpVtbl[4]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), attribute);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, ID2D1Factory**, void>)(lpVtbl[5]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::RemoveSegmentDataAtEnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult RemoveSegmentDataAtEnd(uint dataCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, uint, int>)(lpVtbl[6]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), dataCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::UpdateSegmentData"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult UpdateSegmentData(float* data, uint dataCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, float*, uint, uint, int>)(lpVtbl[7]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), data, dataCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::GetSegmentData"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult GetSegmentData(float* data, uint dataCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, float*, uint, uint, int>)(lpVtbl[8]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), data, dataCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::GetSegmentDataCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public uint GetSegmentDataCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, uint>)(lpVtbl[9]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::RemoveCommandsAtEnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult RemoveCommandsAtEnd(uint commandsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, uint, int>)(lpVtbl[10]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), commandsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::UpdateCommands"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult UpdateCommands(SvgPathCommand* commands, uint commandsCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, SvgPathCommand*, uint, uint, int>)(lpVtbl[11]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), commands, commandsCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::GetCommands"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult GetCommands(SvgPathCommand* commands, uint commandsCount, uint startIndex)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, SvgPathCommand*, uint, uint, int>)(lpVtbl[12]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), commands, commandsCount, startIndex);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::GetCommandsCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public uint GetCommandsCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, uint>)(lpVtbl[13]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgPathData::CreatePathGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreatePathGeometry(Common.FillMode fillMode, ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgPathData*, Common.FillMode, ID2D1PathGeometry1**, int>)(lpVtbl[14]))((ID2D1SvgPathData*)Unsafe.AsPointer(ref this), fillMode, pathGeometry);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement"]/*' />
+/// <unmanaged>ID2D1SvgElement</unmanaged>
+[Guid("ac7b67a6-183e-49c1-a823-0ebe40b0db29")]
+[NativeTypeName("struct ID2D1SvgElement : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1SvgElement
+{
+	public static ref readonly Guid IID_ID2D1SvgElement
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA6, 0x67, 0x7B, 0xAC,
+				0x3E, 0x18,
+				0xC1, 0x49,
+				0xA8,
+				0x23,
+				0x0E,
+				0xBE,
+				0x40,
+				0xB0,
+				0xDB,
+				0x29
+			};
+
+			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_ID2D1SvgElement));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetDocument"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetDocument(ID2D1SvgDocument** document)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgDocument**, void>)(lpVtbl[4]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), document);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetTagName"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetTagName(ushort* name, uint nameCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, uint, int>)(lpVtbl[5]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, nameCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetTagNameLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public uint GetTagNameLength()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, uint>)(lpVtbl[6]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::IsTextContent"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Bool32 IsTextContent()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, Bool32>)(lpVtbl[7]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetParent"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void GetParent(ID2D1SvgElement** parent)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement**, void>)(lpVtbl[8]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), parent);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::HasChildren"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public Bool32 HasChildren()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, Bool32>)(lpVtbl[9]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetFirstChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void GetFirstChild(ID2D1SvgElement** child)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement**, void>)(lpVtbl[10]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), child);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetLastChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void GetLastChild(ID2D1SvgElement** child)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement**, void>)(lpVtbl[11]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), child);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetPreviousChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult GetPreviousChild(ID2D1SvgElement* referenceChild, ID2D1SvgElement** previousChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement*, ID2D1SvgElement**, int>)(lpVtbl[12]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), referenceChild, previousChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetNextChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetNextChild(ID2D1SvgElement* referenceChild, ID2D1SvgElement** nextChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement*, ID2D1SvgElement**, int>)(lpVtbl[13]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), referenceChild, nextChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::InsertChildBefore"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult InsertChildBefore(ID2D1SvgElement* newChild, ID2D1SvgElement* referenceChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement*, ID2D1SvgElement*, int>)(lpVtbl[14]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), newChild, referenceChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::AppendChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult AppendChild(ID2D1SvgElement* newChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement*, int>)(lpVtbl[15]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), newChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::ReplaceChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult ReplaceChild(ID2D1SvgElement* newChild, ID2D1SvgElement* oldChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement*, ID2D1SvgElement*, int>)(lpVtbl[16]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), newChild, oldChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::RemoveChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult RemoveChild(ID2D1SvgElement* oldChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ID2D1SvgElement*, int>)(lpVtbl[17]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), oldChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::CreateChild"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateChild(ushort* tagName, ID2D1SvgElement** newChild)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, ID2D1SvgElement**, int>)(lpVtbl[18]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), tagName, newChild);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::IsAttributeSpecified"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public Bool32 IsAttributeSpecified(ushort* name, Bool32* inherited)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, Bool32*, Bool32>)(lpVtbl[19]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, inherited);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetSpecifiedAttributeCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public uint GetSpecifiedAttributeCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, uint>)(lpVtbl[20]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetSpecifiedAttributeName"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult GetSpecifiedAttributeName(uint index, ushort* name, uint nameCount, Bool32* inherited)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, uint, ushort*, uint, Bool32*, int>)(lpVtbl[21]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), index, name, nameCount, inherited);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetSpecifiedAttributeNameLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult GetSpecifiedAttributeNameLength(uint index, uint* nameLength, Bool32* inherited)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, uint, uint*, Bool32*, int>)(lpVtbl[22]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), index, nameLength, inherited);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::RemoveAttribute"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult RemoveAttribute(ushort* name)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, int>)(lpVtbl[23]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::SetTextValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult SetTextValue(ushort* name, uint nameCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, uint, int>)(lpVtbl[24]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, nameCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetTextValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult GetTextValue(ushort* name, uint nameCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, uint, int>)(lpVtbl[25]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, nameCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetTextValueLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public uint GetTextValueLength()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, uint>)(lpVtbl[26]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::SetAttributeValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult SetAttributeValue(ushort* name, ID2D1SvgAttribute* value)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, ID2D1SvgAttribute*, int>)(lpVtbl[27]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, value);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::SetAttributeValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult SetAttributeValue(ushort* name, SvgAttributePodType type, void* value, uint valueSizeInBytes)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, SvgAttributePodType, void*, uint, int>)(lpVtbl[28]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, type, value, valueSizeInBytes);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::SetAttributeValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult SetAttributeValue(ushort* name, SvgAttributeStringType type, ushort* value)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, SvgAttributeStringType, ushort*, int>)(lpVtbl[29]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, type, value);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetAttributeValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult GetAttributeValue(ushort* name, Guid* riid, void** value)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, Guid*, void**, int>)(lpVtbl[30]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, riid, value);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetAttributeValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult GetAttributeValue(ushort* name, SvgAttributePodType type, void* value, uint valueSizeInBytes)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, SvgAttributePodType, void*, uint, int>)(lpVtbl[31]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, type, value, valueSizeInBytes);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetAttributeValue"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult GetAttributeValue(ushort* name, SvgAttributeStringType type, ushort* value, uint valueCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, SvgAttributeStringType, ushort*, uint, int>)(lpVtbl[32]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, type, value, valueCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgElement::GetAttributeValueLength"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult GetAttributeValueLength(ushort* name, SvgAttributeStringType type, uint* valueLength)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgElement*, ushort*, SvgAttributeStringType, uint*, int>)(lpVtbl[33]))((ID2D1SvgElement*)Unsafe.AsPointer(ref this), name, type, valueLength);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument"]/*' />
+/// <unmanaged>ID2D1SvgDocument</unmanaged>
+[Guid("86b88e4d-afa4-4d7b-88e4-68a51c4a0aec")]
+[NativeTypeName("struct ID2D1SvgDocument : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1SvgDocument
+{
+	public static ref readonly Guid IID_ID2D1SvgDocument
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x4D, 0x8E, 0xB8, 0x86,
+				0xA4, 0xAF,
+				0x7B, 0x4D,
+				0x88,
+				0xE4,
+				0x68,
+				0xA5,
+				0x1C,
+				0x4A,
+				0x0A,
+				0xEC
+			};
+
+			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_ID2D1SvgDocument));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::SetViewportSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetViewportSize(System.Drawing.SizeF* viewportSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, System.Drawing.SizeF*, int>)(lpVtbl[4]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), viewportSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::GetViewportSize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public System.Drawing.SizeF GetViewportSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, System.Drawing.SizeF>)(lpVtbl[5]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::SetRoot"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetRoot(ID2D1SvgElement* root)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, ID2D1SvgElement*, int>)(lpVtbl[6]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), root);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::GetRoot"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void GetRoot(ID2D1SvgElement** root)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, ID2D1SvgElement**, void>)(lpVtbl[7]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), root);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::FindElementById"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult FindElementById(ushort* id, ID2D1SvgElement** svgElement)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, ushort*, ID2D1SvgElement**, int>)(lpVtbl[8]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), id, svgElement);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::Serialize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult Serialize(Com.IStream* outputXmlStream, ID2D1SvgElement* subtree)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, Com.IStream*, ID2D1SvgElement*, int>)(lpVtbl[9]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), outputXmlStream, subtree);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::Deserialize"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult Deserialize(Com.IStream* inputXmlStream, ID2D1SvgElement** subtree)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, Com.IStream*, ID2D1SvgElement**, int>)(lpVtbl[10]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), inputXmlStream, subtree);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::CreatePaint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreatePaint(SvgPaintType paintType, Common.ColorF* color, ushort* id, ID2D1SvgPaint** paint)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, SvgPaintType, Common.ColorF*, ushort*, ID2D1SvgPaint**, int>)(lpVtbl[11]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), paintType, color, id, paint);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::CreateStrokeDashArray"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateStrokeDashArray(SvgLength* dashes, uint dashesCount, ID2D1SvgStrokeDashArray** strokeDashArray)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, SvgLength*, uint, ID2D1SvgStrokeDashArray**, int>)(lpVtbl[12]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), dashes, dashesCount, strokeDashArray);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::CreatePointCollection"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreatePointCollection(System.Drawing.PointF** points, uint pointsCount, ID2D1SvgPointCollection** pointCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, System.Drawing.PointF**, uint, ID2D1SvgPointCollection**, int>)(lpVtbl[13]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), points, pointsCount, pointCollection);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgDocument::CreatePathData"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreatePathData(float* segmentData, uint segmentDataCount, SvgPathCommand* commands, uint commandsCount, ID2D1SvgPathData** pathData)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgDocument*, float*, uint, SvgPathCommand*, uint, ID2D1SvgPathData**, int>)(lpVtbl[14]))((ID2D1SvgDocument*)Unsafe.AsPointer(ref this), segmentData, segmentDataCount, commands, commandsCount, pathData);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1InkStyle"]/*' />
+/// <unmanaged>ID2D1InkStyle</unmanaged>
+[Guid("bae8b344-23fc-4071-8cb5-d05d6f073848")]
+[NativeTypeName("struct ID2D1InkStyle : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1InkStyle
+{
+	public static ref readonly Guid IID_ID2D1InkStyle
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x44, 0xB3, 0xE8, 0xBA,
+				0xFC, 0x23,
+				0x71, 0x40,
+				0x8C,
+				0xB5,
+				0xD0,
+				0x5D,
+				0x6F,
+				0x07,
+				0x38,
+				0x48
+			};
+
+			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_ID2D1InkStyle));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1InkStyle*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1InkStyle*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1InkStyle::SetNibTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetNibTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1InkStyle*, Matrix3x2*, void>)(lpVtbl[4]))((ID2D1InkStyle*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1InkStyle::GetNibTransform"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetNibTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1InkStyle*, Matrix3x2**, void>)(lpVtbl[5]))((ID2D1InkStyle*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1InkStyle::SetNibShape"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void SetNibShape(InkNibShape nibShape)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1InkStyle*, InkNibShape, void>)(lpVtbl[6]))((ID2D1InkStyle*)Unsafe.AsPointer(ref this), nibShape);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1InkStyle::GetNibShape"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.InkNibShape GetNibShape()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1InkStyle*, Graphics.Direct2D.InkNibShape>)(lpVtbl[7]))((ID2D1InkStyle*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink"]/*' />
+/// <unmanaged>ID2D1Ink</unmanaged>
+[Guid("b499923b-7029-478f-a8b3-432c7c5f5312")]
+[NativeTypeName("struct ID2D1Ink : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1Ink
+{
+	public static ref readonly Guid IID_ID2D1Ink
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x3B, 0x92, 0x99, 0xB4,
+				0x29, 0x70,
+				0x8F, 0x47,
+				0xA8,
+				0xB3,
+				0x43,
+				0x2C,
+				0x7C,
+				0x5F,
+				0x53,
+				0x12
+			};
+
+			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_ID2D1Ink));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Ink*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Ink*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::SetStartPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetStartPoint(InkPoint* startPoint)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Ink*, InkPoint*, void>)(lpVtbl[4]))((ID2D1Ink*)Unsafe.AsPointer(ref this), startPoint);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::GetStartPoint"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public Graphics.Direct2D.InkPoint GetStartPoint()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, Graphics.Direct2D.InkPoint>)(lpVtbl[5]))((ID2D1Ink*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::AddSegments"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult AddSegments(InkBezierSegment* segments, uint segmentsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, InkBezierSegment*, uint, int>)(lpVtbl[6]))((ID2D1Ink*)Unsafe.AsPointer(ref this), segments, segmentsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::RemoveSegmentsAtEnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult RemoveSegmentsAtEnd(uint segmentsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, uint, int>)(lpVtbl[7]))((ID2D1Ink*)Unsafe.AsPointer(ref this), segmentsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::SetSegments"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetSegments(uint startSegment, InkBezierSegment* segments, uint segmentsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, uint, InkBezierSegment*, uint, int>)(lpVtbl[8]))((ID2D1Ink*)Unsafe.AsPointer(ref this), startSegment, segments, segmentsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::SetSegmentAtEnd"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetSegmentAtEnd(InkBezierSegment* segment)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, InkBezierSegment*, int>)(lpVtbl[9]))((ID2D1Ink*)Unsafe.AsPointer(ref this), segment);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::GetSegmentCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public uint GetSegmentCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, uint>)(lpVtbl[10]))((ID2D1Ink*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::GetSegments"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetSegments(uint startSegment, InkBezierSegment* segments, uint segmentsCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, uint, InkBezierSegment*, uint, int>)(lpVtbl[11]))((ID2D1Ink*)Unsafe.AsPointer(ref this), startSegment, segments, segmentsCount);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::StreamAsGeometry"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult StreamAsGeometry(ID2D1InkStyle* inkStyle, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, ID2D1InkStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1Ink*)Unsafe.AsPointer(ref this), inkStyle, worldTransform, flatteningTolerance, geometrySink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Ink::GetBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetBounds(ID2D1InkStyle* inkStyle, Matrix3x2* worldTransform, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Ink*, ID2D1InkStyle*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[13]))((ID2D1Ink*)Unsafe.AsPointer(ref this), inkStyle, worldTransform, bounds);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientMesh"]/*' />
+/// <unmanaged>ID2D1GradientMesh</unmanaged>
+[Guid("f292e401-c050-4cde-83d7-04962d3b23c2")]
+[NativeTypeName("struct ID2D1GradientMesh : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1GradientMesh
+{
+	public static ref readonly Guid IID_ID2D1GradientMesh
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x01, 0xE4, 0x92, 0xF2,
+				0x50, 0xC0,
+				0xDE, 0x4C,
+				0x83,
+				0xD7,
+				0x04,
+				0x96,
+				0x2D,
+				0x3B,
+				0x23,
+				0xC2
+			};
+
+			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_ID2D1GradientMesh));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GradientMesh*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GradientMesh*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientMesh::GetPatchCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public uint GetPatchCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientMesh*, uint>)(lpVtbl[4]))((ID2D1GradientMesh*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GradientMesh::GetPatches"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetPatches(uint startIndex, GradientMeshPatch* patches, uint patchesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GradientMesh*, uint, GradientMeshPatch*, uint, int>)(lpVtbl[5]))((ID2D1GradientMesh*)Unsafe.AsPointer(ref this), startIndex, patches, patchesCount);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSource"]/*' />
+/// <unmanaged>ID2D1ImageSource</unmanaged>
+[Guid("c9b664e5-74a1-4378-9ac2-eefc37a3f4d8")]
+[NativeTypeName("struct ID2D1ImageSource : ID2D1Image")]
+[NativeInheritance("ID2D1Image")]
+public unsafe partial struct ID2D1ImageSource
+{
+	public static ref readonly Guid IID_ID2D1ImageSource
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE5, 0x64, 0xB6, 0xC9,
+				0xA1, 0x74,
+				0x78, 0x43,
+				0x9A,
+				0xC2,
+				0xEE,
+				0xFC,
+				0x37,
+				0xA3,
+				0xF4,
+				0xD8
+			};
+
+			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_ID2D1ImageSource));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageSource*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1ImageSource*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSource::OfferResources"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult OfferResources()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageSource*, int>)(lpVtbl[4]))((ID2D1ImageSource*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSource::TryReclaimResources"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult TryReclaimResources(Bool32* resourcesDiscarded)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageSource*, Bool32*, int>)(lpVtbl[5]))((ID2D1ImageSource*)Unsafe.AsPointer(ref this), resourcesDiscarded);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSourceFromWic"]/*' />
+/// <unmanaged>ID2D1ImageSourceFromWic</unmanaged>
+[Guid("77395441-1c8f-4555-8683-f50dab0fe792")]
+[NativeTypeName("struct ID2D1ImageSourceFromWic : ID2D1ImageSource")]
+[NativeInheritance("ID2D1ImageSource")]
+public unsafe partial struct ID2D1ImageSourceFromWic
+{
+	public static ref readonly Guid IID_ID2D1ImageSourceFromWic
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x41, 0x54, 0x39, 0x77,
+				0x8F, 0x1C,
+				0x55, 0x45,
+				0x86,
+				0x83,
+				0xF5,
+				0x0D,
+				0xAB,
+				0x0F,
+				0xE7,
+				0x92
+			};
+
+			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_ID2D1ImageSourceFromWic));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ImageSource.OfferResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult OfferResources()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, int>)(lpVtbl[3]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ImageSource.TryReclaimResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult TryReclaimResources(Bool32* resourcesDiscarded)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, Bool32*, int>)(lpVtbl[4]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), resourcesDiscarded);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, ID2D1Factory**, void>)(lpVtbl[5]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSourceFromWic::EnsureCached"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult EnsureCached(Common.RectU* rectangleToFill)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, Common.RectU*, int>)(lpVtbl[6]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), rectangleToFill);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSourceFromWic::TrimCache"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult TrimCache(Common.RectU* rectangleToPreserve)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, Common.RectU*, int>)(lpVtbl[7]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), rectangleToPreserve);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ImageSourceFromWic::GetSource"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void GetSource(Graphics.Imaging.IWICBitmapSource** wicBitmapSource)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, Graphics.Imaging.IWICBitmapSource**, void>)(lpVtbl[8]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), wicBitmapSource);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformedImageSource"]/*' />
+/// <unmanaged>ID2D1TransformedImageSource</unmanaged>
+[Guid("7f1f79e5-2796-416c-8f55-700f911445e5")]
+[NativeTypeName("struct ID2D1TransformedImageSource : ID2D1Image")]
+[NativeInheritance("ID2D1Image")]
+public unsafe partial struct ID2D1TransformedImageSource
+{
+	public static ref readonly Guid IID_ID2D1TransformedImageSource
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE5, 0x79, 0x1F, 0x7F,
+				0x96, 0x27,
+				0x6C, 0x41,
+				0x8F,
+				0x55,
+				0x70,
+				0x0F,
+				0x91,
+				0x14,
+				0x45,
+				0xE5
+			};
+
+			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_ID2D1TransformedImageSource));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformedImageSource*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1TransformedImageSource*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformedImageSource::GetSource"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetSource(ID2D1ImageSource** imageSource)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformedImageSource*, ID2D1ImageSource**, void>)(lpVtbl[4]))((ID2D1TransformedImageSource*)Unsafe.AsPointer(ref this), imageSource);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1TransformedImageSource::GetProperties"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetProperties(TransformedImageSourceProperties* properties)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1TransformedImageSource*, TransformedImageSourceProperties*, void>)(lpVtbl[5]))((ID2D1TransformedImageSource*)Unsafe.AsPointer(ref this), properties);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1LookupTable3D"]/*' />
+/// <unmanaged>ID2D1LookupTable3D</unmanaged>
+[Guid("53dd9855-a3b0-4d5b-82e1-26e25c5e5797")]
+[NativeTypeName("struct ID2D1LookupTable3D : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1LookupTable3D
+{
+	public static ref readonly Guid IID_ID2D1LookupTable3D
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x55, 0x98, 0xDD, 0x53,
+				0xB0, 0xA3,
+				0x5B, 0x4D,
+				0x82,
+				0xE1,
+				0x26,
+				0xE2,
+				0x5C,
+				0x5E,
+				0x57,
+				0x97
+			};
+
+			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_ID2D1LookupTable3D));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1LookupTable3D*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1LookupTable3D*)Unsafe.AsPointer(ref this), factory);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2"]/*' />
+/// <unmanaged>ID2D1DeviceContext2</unmanaged>
+[Guid("394ea6a3-0c34-4321-950b-6ca20f0be6c7")]
+[NativeTypeName("struct ID2D1DeviceContext2 : ID2D1DeviceContext1")]
+[NativeInheritance("ID2D1DeviceContext1")]
+public unsafe partial struct ID2D1DeviceContext2
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA3, 0xA6, 0x4E, 0x39,
+				0x34, 0x0C,
+				0x21, 0x43,
+				0x95,
+				0x0B,
+				0x6C,
+				0xA2,
+				0x0F,
+				0x0B,
+				0xE6,
+				0xC7
+			};
+
+			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_ID2D1DeviceContext2));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[3]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateStrokedGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, float strokeWidth, ID2D1StrokeStyle* strokeStyle, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, float, float, ID2D1StrokeStyle*, ID2D1GeometryRealization**, int>)(lpVtbl[4]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[5]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometryRealization, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[6]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[7]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[8]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[9]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[10]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[11]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Guid*, ID2D1Effect**, int>)(lpVtbl[12]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[13]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[14]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[15]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1CommandList**, int>)(lpVtbl[16]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[17]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, BufferPrecision, Bool32>)(lpVtbl[18]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[19]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[20]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetGlyphRunWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[21]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Device**, void>)(lpVtbl[22]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, void>)(lpVtbl[23]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image**, void>)(lpVtbl[24]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RenderingControls*, void>)(lpVtbl[25]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RenderingControls*, void>)(lpVtbl[26]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, PrimitiveBlend, void>)(lpVtbl[27]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[28]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, UnitMode, void>)(lpVtbl[29]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Direct2D.UnitMode>)(lpVtbl[30]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[31]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[32]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[33]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[34]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[35]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[36]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, uint*, int>)(lpVtbl[37]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[38]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectRequiredInputRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[39]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[40]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[41]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[42]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[43]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[44]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[45]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[46]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[47]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[48]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[49]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[50]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Mesh**, int>)(lpVtbl[51]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[52]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[53]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[54]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[55]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[56]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[57]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[58]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[59]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[60]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[61]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[62]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[63]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[64]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[65]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[66]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Matrix3x2*, void>)(lpVtbl[67]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Matrix3x2**, void>)(lpVtbl[68]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, AntialiasMode, void>)(lpVtbl[69]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[70]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, TextAntialiasMode, void>)(lpVtbl[71]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[72]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[73]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[74]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong, ulong, void>)(lpVtbl[75]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong*, ulong*, void>)(lpVtbl[76]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[77]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, void>)(lpVtbl[78]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong*, ulong*, int>)(lpVtbl[79]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1DrawingStateBlock*, void>)(lpVtbl[80]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1DrawingStateBlock*, void>)(lpVtbl[81]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.RectF*, AntialiasMode, void>)(lpVtbl[82]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, void>)(lpVtbl[83]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.ColorF*, void>)(lpVtbl[84]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, void>)(lpVtbl[85]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong*, ulong*, int>)(lpVtbl[86]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[87]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, float, float, void>)(lpVtbl[88]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, float*, float*, void>)(lpVtbl[89]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.SizeF>)(lpVtbl[90]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[91]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(92)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, uint>)(lpVtbl[92]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(93)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RenderTargetProperties*, Bool32>)(lpVtbl[93]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(94)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Factory**, void>)(lpVtbl[94]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateInk"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(95)]
+	public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[95]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), startPoint, ink);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateInkStyle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(96)]
+	public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[96]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateGradientMesh"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(97)]
+	public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[97]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateImageSourceFromWic"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(98)]
+	public HResult CreateImageSourceFromWic(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, ImageSourceLoadingOptions loadingOptions, Common.AlphaMode alphaMode, ID2D1ImageSourceFromWic** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[98]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateLookupTable3D"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(99)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[99]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateImageSourceFromDxgi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(100)]
+	public HResult CreateImageSourceFromDxgi(Graphics.Dxgi.IDXGISurface** surfaces, uint surfaceCount, Graphics.Dxgi.Common.ColorSpaceType colorSpace, ImageSourceFromDxgiOptions options, ID2D1ImageSource** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[100]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::GetGradientMeshWorldBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(101)]
+	public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[101]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::DrawInk"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(102)]
+	public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[102]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::DrawGradientMesh"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(103)]
+	public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GradientMesh*, void>)(lpVtbl[103]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::DrawGdiMetafile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(104)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[104]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext2::CreateTransformedImageSource"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(105)]
+	public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[105]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device2"]/*' />
+/// <unmanaged>ID2D1Device2</unmanaged>
+[Guid("a44472e1-8dfb-4e60-8492-6e2861c9ca8b")]
+[NativeTypeName("struct ID2D1Device2 : ID2D1Device1")]
+[NativeInheritance("ID2D1Device1")]
+public unsafe partial struct ID2D1Device2
+{
+	public static ref readonly Guid IID_ID2D1Device2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE1, 0x72, 0x44, 0xA4,
+				0xFB, 0x8D,
+				0x60, 0x4E,
+				0x84,
+				0x92,
+				0x6E,
+				0x28,
+				0x61,
+				0xC9,
+				0xCA,
+				0x8B
+			};
+
+			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_ID2D1Device2));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public Graphics.Direct2D.RenderingPriority GetRenderingPriority()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, Graphics.Direct2D.RenderingPriority>)(lpVtbl[3]))((ID2D1Device2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetRenderingPriority(RenderingPriority renderingPriority)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device2*, RenderingPriority, void>)(lpVtbl[4]))((ID2D1Device2*)Unsafe.AsPointer(ref this), renderingPriority);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[5]))((ID2D1Device2*)Unsafe.AsPointer(ref this), options, deviceContext1);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[6]))((ID2D1Device2*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device2*, ulong, void>)(lpVtbl[7]))((ID2D1Device2*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, ulong>)(lpVtbl[8]))((ID2D1Device2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.ClearResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device2*, uint, void>)(lpVtbl[9]))((ID2D1Device2*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device2*, ID2D1Factory**, void>)(lpVtbl[10]))((ID2D1Device2*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device2::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[11]))((ID2D1Device2*)Unsafe.AsPointer(ref this), options, deviceContext2);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device2::FlushDeviceContexts"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device2*, ID2D1Bitmap*, void>)(lpVtbl[12]))((ID2D1Device2*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device2::GetDxgiDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[13]))((ID2D1Device2*)Unsafe.AsPointer(ref this), dxgiDevice);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory3"]/*' />
+/// <unmanaged>ID2D1Factory3</unmanaged>
+[Guid("0869759f-4f00-413f-b03e-2bda45404d0f")]
+[NativeTypeName("struct ID2D1Factory3 : ID2D1Factory2")]
+[NativeInheritance("ID2D1Factory2")]
+public unsafe partial struct ID2D1Factory3
+{
+	public static ref readonly Guid IID_ID2D1Factory3
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x9F, 0x75, 0x69, 0x08,
+				0x00, 0x4F,
+				0x3F, 0x41,
+				0xB0,
+				0x3E,
+				0x2B,
+				0xDA,
+				0x45,
+				0x40,
+				0x4D,
+				0x0F
+			};
+
+			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_ID2D1Factory3));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[3]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[4]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[5]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, ID2D1PathGeometry1**, int>)(lpVtbl[6]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[7]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[8]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[9]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromString" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[10]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, int>)(lpVtbl[11]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, uint, uint*, uint*, int>)(lpVtbl[12]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, ID2D1Properties**, int>)(lpVtbl[13]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, int>)(lpVtbl[14]))((ID2D1Factory3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory3*, float*, float*, void>)(lpVtbl[15]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[16]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[17]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[18]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[19]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[20]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, ID2D1PathGeometry**, int>)(lpVtbl[21]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[22]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[23]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[24]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[25]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[26]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[27]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory3::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[28]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink2"]/*' />
+/// <unmanaged>ID2D1CommandSink2</unmanaged>
+[Guid("3bab440e-417e-47df-a2e2-bc0be6a00916")]
+[NativeTypeName("struct ID2D1CommandSink2 : ID2D1CommandSink1")]
+[NativeInheritance("ID2D1CommandSink1")]
+public unsafe partial struct ID2D1CommandSink2
+{
+	public static ref readonly Guid IID_ID2D1CommandSink2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x0E, 0x44, 0xAB, 0x3B,
+				0x7E, 0x41,
+				0xDF, 0x47,
+				0xA2,
+				0xE2,
+				0xBC,
+				0x0B,
+				0xE6,
+				0xA0,
+				0x09,
+				0x16
+			};
+
+			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_ID2D1CommandSink2));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, PrimitiveBlend, int>)(lpVtbl[3]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult BeginDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[4]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult EndDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[5]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, AntialiasMode, int>)(lpVtbl[6]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetTags(ulong tag1, ulong tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ulong, ulong, int>)(lpVtbl[7]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, TextAntialiasMode, int>)(lpVtbl[8]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[9]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetTransform(Matrix3x2* transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Matrix3x2*, int>)(lpVtbl[10]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, PrimitiveBlend, int>)(lpVtbl[11]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult SetUnitMode(UnitMode unitMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, UnitMode, int>)(lpVtbl[12]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult Clear(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Common.ColorF*, int>)(lpVtbl[13]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[14]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[17]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[18]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[19]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[20]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[21]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[22]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[24]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Common.RectF*, AntialiasMode, int>)(lpVtbl[25]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult PushLayer(LayerParameters1* layerParameters1, ID2D1Layer* layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[26]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), layerParameters1, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult PopAxisAlignedClip()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[27]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult PopLayer()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[28]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink2::DrawInk"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[29]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink2::DrawGradientMesh"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1GradientMesh*, int>)(lpVtbl[30]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink2::DrawGdiMetafile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[31]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafile1"]/*' />
+/// <unmanaged>ID2D1GdiMetafile1</unmanaged>
+[Guid("2e69f9e8-dd3f-4bf9-95ba-c04f49d788df")]
+[NativeTypeName("struct ID2D1GdiMetafile1 : ID2D1GdiMetafile")]
+[NativeInheritance("ID2D1GdiMetafile")]
+public unsafe partial struct ID2D1GdiMetafile1
+{
+	public static ref readonly Guid IID_ID2D1GdiMetafile1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xE8, 0xF9, 0x69, 0x2E,
+				0x3F, 0xDD,
+				0xF9, 0x4B,
+				0x95,
+				0xBA,
+				0xC0,
+				0x4F,
+				0x49,
+				0xD7,
+				0x88,
+				0xDF
+			};
+
+			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_ID2D1GdiMetafile1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1GdiMetafile.Stream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Stream(ID2D1GdiMetafileSink* sink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, ID2D1GdiMetafileSink*, int>)(lpVtbl[3]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), sink);
+	}
+
+	/// <inheritdoc cref="ID2D1GdiMetafile.GetBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetBounds(Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, ID2D1Factory**, void>)(lpVtbl[5]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafile1::GetDpi"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetDpi(float* dpiX, float* dpiY)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, float*, float*, int>)(lpVtbl[6]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafile1::GetSourceBounds"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult GetSourceBounds(Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, Common.RectF*, int>)(lpVtbl[7]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), bounds);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafileSink1"]/*' />
+/// <unmanaged>ID2D1GdiMetafileSink1</unmanaged>
+[Guid("fd0ecb6b-91e6-411e-8655-395e760f91b4")]
+[NativeTypeName("struct ID2D1GdiMetafileSink1 : ID2D1GdiMetafileSink")]
+[NativeInheritance("ID2D1GdiMetafileSink")]
+public unsafe partial struct ID2D1GdiMetafileSink1
+{
+	public static ref readonly Guid IID_ID2D1GdiMetafileSink1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x6B, 0xCB, 0x0E, 0xFD,
+				0xE6, 0x91,
+				0x1E, 0x41,
+				0x86,
+				0x55,
+				0x39,
+				0x5E,
+				0x76,
+				0x0F,
+				0x91,
+				0xB4
+			};
+
+			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_ID2D1GdiMetafileSink1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1GdiMetafileSink.ProcessRecord" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult ProcessRecord(uint recordType, void* recordData, uint recordDataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafileSink1*, uint, void*, uint, int>)(lpVtbl[3]))((ID2D1GdiMetafileSink1*)Unsafe.AsPointer(ref this), recordType, recordData, recordDataSize);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1GdiMetafileSink1::ProcessRecord"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult ProcessRecord(uint recordType, void* recordData, uint recordDataSize, uint flags)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafileSink1*, uint, void*, uint, uint, int>)(lpVtbl[4]))((ID2D1GdiMetafileSink1*)Unsafe.AsPointer(ref this), recordType, recordData, recordDataSize, flags);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SpriteBatch"]/*' />
+/// <unmanaged>ID2D1SpriteBatch</unmanaged>
+[Guid("4dc583bf-3a10-438a-8722-e9765224f1f1")]
+[NativeTypeName("struct ID2D1SpriteBatch : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1SpriteBatch
+{
+	public static ref readonly Guid IID_ID2D1SpriteBatch
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xBF, 0x83, 0xC5, 0x4D,
+				0x10, 0x3A,
+				0x8A, 0x43,
+				0x87,
+				0x22,
+				0xE9,
+				0x76,
+				0x52,
+				0x24,
+				0xF1,
+				0xF1
+			};
+
+			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_ID2D1SpriteBatch));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SpriteBatch*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1SpriteBatch*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SpriteBatch::AddSprites"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult AddSprites(uint spriteCount, Common.RectF* destinationRectangles, Common.RectU* sourceRectangles, Common.ColorF* colors, Matrix3x2* transforms, uint destinationRectanglesStride, uint sourceRectanglesStride, uint colorsStride, uint transformsStride)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SpriteBatch*, uint, Common.RectF*, Common.RectU*, Common.ColorF*, Matrix3x2*, uint, uint, uint, uint, int>)(lpVtbl[4]))((ID2D1SpriteBatch*)Unsafe.AsPointer(ref this), spriteCount, destinationRectangles, sourceRectangles, colors, transforms, destinationRectanglesStride, sourceRectanglesStride, colorsStride, transformsStride);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SpriteBatch::SetSprites"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult SetSprites(uint startIndex, uint spriteCount, Common.RectF* destinationRectangles, Common.RectU* sourceRectangles, Common.ColorF* colors, Matrix3x2* transforms, uint destinationRectanglesStride, uint sourceRectanglesStride, uint colorsStride, uint transformsStride)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SpriteBatch*, uint, uint, Common.RectF*, Common.RectU*, Common.ColorF*, Matrix3x2*, uint, uint, uint, uint, int>)(lpVtbl[5]))((ID2D1SpriteBatch*)Unsafe.AsPointer(ref this), startIndex, spriteCount, destinationRectangles, sourceRectangles, colors, transforms, destinationRectanglesStride, sourceRectanglesStride, colorsStride, transformsStride);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SpriteBatch::GetSprites"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetSprites(uint startIndex, uint spriteCount, Common.RectF* destinationRectangles, Common.RectU* sourceRectangles, Common.ColorF* colors, Matrix3x2** transforms)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SpriteBatch*, uint, uint, Common.RectF*, Common.RectU*, Common.ColorF*, Matrix3x2**, int>)(lpVtbl[6]))((ID2D1SpriteBatch*)Unsafe.AsPointer(ref this), startIndex, spriteCount, destinationRectangles, sourceRectangles, colors, transforms);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SpriteBatch::GetSpriteCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public uint GetSpriteCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SpriteBatch*, uint>)(lpVtbl[7]))((ID2D1SpriteBatch*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SpriteBatch::Clear"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void Clear()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SpriteBatch*, void>)(lpVtbl[8]))((ID2D1SpriteBatch*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext3"]/*' />
+/// <unmanaged>ID2D1DeviceContext3</unmanaged>
+[Guid("235a7496-8351-414c-bcd4-6672ab2d8e00")]
+[NativeTypeName("struct ID2D1DeviceContext3 : ID2D1DeviceContext2")]
+[NativeInheritance("ID2D1DeviceContext2")]
+public unsafe partial struct ID2D1DeviceContext3
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext3
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x96, 0x74, 0x5A, 0x23,
+				0x51, 0x83,
+				0x4C, 0x41,
+				0xBC,
+				0xD4,
+				0x66,
+				0x72,
+				0xAB,
+				0x2D,
+				0x8E,
+				0x00
+			};
+
+			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_ID2D1DeviceContext3));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[3]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), startPoint, ink);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInkStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[4]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[5]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromWic" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateImageSourceFromWic(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, ImageSourceLoadingOptions loadingOptions, Common.AlphaMode alphaMode, ID2D1ImageSourceFromWic** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[6]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateLookupTable3D" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[7]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromDxgi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateImageSourceFromDxgi(Graphics.Dxgi.IDXGISurface** surfaces, uint surfaceCount, Graphics.Dxgi.Common.ColorSpaceType colorSpace, ImageSourceFromDxgiOptions options, ID2D1ImageSource** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[8]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.GetGradientMeshWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[9]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[10]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GradientMesh*, void>)(lpVtbl[11]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[12]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateTransformedImageSource" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[13]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[14]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateStrokedGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, float strokeWidth, ID2D1StrokeStyle* strokeStyle, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, float, float, ID2D1StrokeStyle*, ID2D1GeometryRealization**, int>)(lpVtbl[15]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[16]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometryRealization, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[17]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[18]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[19]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[20]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[21]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[22]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Guid*, ID2D1Effect**, int>)(lpVtbl[23]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[24]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[25]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[26]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1CommandList**, int>)(lpVtbl[27]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[28]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, BufferPrecision, Bool32>)(lpVtbl[29]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[30]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[31]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetGlyphRunWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[32]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Device**, void>)(lpVtbl[33]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, void>)(lpVtbl[34]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image**, void>)(lpVtbl[35]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RenderingControls*, void>)(lpVtbl[36]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RenderingControls*, void>)(lpVtbl[37]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, PrimitiveBlend, void>)(lpVtbl[38]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[39]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, UnitMode, void>)(lpVtbl[40]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Direct2D.UnitMode>)(lpVtbl[41]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[42]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[43]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[44]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[45]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[46]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[47]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, uint*, int>)(lpVtbl[48]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[49]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectRequiredInputRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[50]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[51]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[52]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[53]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[54]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[55]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[56]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[57]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[58]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[59]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[60]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[61]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Mesh**, int>)(lpVtbl[62]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[63]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[64]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[65]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[66]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[67]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[68]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[69]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[70]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[71]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[72]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[73]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[74]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[75]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[76]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[77]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Matrix3x2*, void>)(lpVtbl[78]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Matrix3x2**, void>)(lpVtbl[79]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, AntialiasMode, void>)(lpVtbl[80]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[81]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, TextAntialiasMode, void>)(lpVtbl[82]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[83]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[84]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[85]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong, ulong, void>)(lpVtbl[86]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong*, ulong*, void>)(lpVtbl[87]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[88]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, void>)(lpVtbl[89]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong*, ulong*, int>)(lpVtbl[90]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1DrawingStateBlock*, void>)(lpVtbl[91]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(92)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1DrawingStateBlock*, void>)(lpVtbl[92]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(93)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.RectF*, AntialiasMode, void>)(lpVtbl[93]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(94)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, void>)(lpVtbl[94]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(95)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.ColorF*, void>)(lpVtbl[95]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(96)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, void>)(lpVtbl[96]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(97)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong*, ulong*, int>)(lpVtbl[97]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(98)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[98]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(99)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, float, float, void>)(lpVtbl[99]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(100)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, float*, float*, void>)(lpVtbl[100]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(101)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.SizeF>)(lpVtbl[101]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(102)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[102]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(103)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, uint>)(lpVtbl[103]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(104)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RenderTargetProperties*, Bool32>)(lpVtbl[104]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(105)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Factory**, void>)(lpVtbl[105]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext3::CreateSpriteBatch"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(106)]
+	public HResult CreateSpriteBatch(ID2D1SpriteBatch** spriteBatch)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1SpriteBatch**, int>)(lpVtbl[106]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), spriteBatch);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext3::DrawSpriteBatch"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(107)]
+	public void DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, void>)(lpVtbl[107]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device3"]/*' />
+/// <unmanaged>ID2D1Device3</unmanaged>
+[Guid("852f2087-802c-4037-ab60-ff2e7ee6fc01")]
+[NativeTypeName("struct ID2D1Device3 : ID2D1Device2")]
+[NativeInheritance("ID2D1Device2")]
+public unsafe partial struct ID2D1Device3
+{
+	public static ref readonly Guid IID_ID2D1Device3
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x87, 0x20, 0x2F, 0x85,
+				0x2C, 0x80,
+				0x37, 0x40,
+				0xAB,
+				0x60,
+				0xFF,
+				0x2E,
+				0x7E,
+				0xE6,
+				0xFC,
+				0x01
+			};
+
+			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_ID2D1Device3));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[3]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext2);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device3*, ID2D1Bitmap*, void>)(lpVtbl[4]))((ID2D1Device3*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[5]))((ID2D1Device3*)Unsafe.AsPointer(ref this), dxgiDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Graphics.Direct2D.RenderingPriority GetRenderingPriority()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, Graphics.Direct2D.RenderingPriority>)(lpVtbl[6]))((ID2D1Device3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void SetRenderingPriority(RenderingPriority renderingPriority)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device3*, RenderingPriority, void>)(lpVtbl[7]))((ID2D1Device3*)Unsafe.AsPointer(ref this), renderingPriority);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[8]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext1);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[9]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device3*, ulong, void>)(lpVtbl[10]))((ID2D1Device3*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, ulong>)(lpVtbl[11]))((ID2D1Device3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.ClearResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device3*, uint, void>)(lpVtbl[12]))((ID2D1Device3*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device3*, ID2D1Factory**, void>)(lpVtbl[13]))((ID2D1Device3*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device3::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[14]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext3);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory4"]/*' />
+/// <unmanaged>ID2D1Factory4</unmanaged>
+[Guid("bd4ec2d2-0662-4bee-ba8e-6f29f032e096")]
+[NativeTypeName("struct ID2D1Factory4 : ID2D1Factory3")]
+[NativeInheritance("ID2D1Factory3")]
+public unsafe partial struct ID2D1Factory4
+{
+	public static ref readonly Guid IID_ID2D1Factory4
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD2, 0xC2, 0x4E, 0xBD,
+				0x62, 0x06,
+				0xEE, 0x4B,
+				0xBA,
+				0x8E,
+				0x6F,
+				0x29,
+				0xF0,
+				0x32,
+				0xE0,
+				0x96
+			};
+
+			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_ID2D1Factory4));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[3]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[4]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[5]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[6]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, ID2D1PathGeometry1**, int>)(lpVtbl[7]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[8]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[9]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[10]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromString" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[11]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, int>)(lpVtbl[12]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, uint, uint*, uint*, int>)(lpVtbl[13]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, ID2D1Properties**, int>)(lpVtbl[14]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, int>)(lpVtbl[15]))((ID2D1Factory4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory4*, float*, float*, void>)(lpVtbl[16]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[17]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[18]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[19]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[20]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[21]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, ID2D1PathGeometry**, int>)(lpVtbl[22]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[23]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[24]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[25]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[26]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[27]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[28]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory4::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[29]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink3"]/*' />
+/// <unmanaged>ID2D1CommandSink3</unmanaged>
+[Guid("18079135-4cf3-4868-bc8e-06067e6d242d")]
+[NativeTypeName("struct ID2D1CommandSink3 : ID2D1CommandSink2")]
+[NativeInheritance("ID2D1CommandSink2")]
+public unsafe partial struct ID2D1CommandSink3
+{
+	public static ref readonly Guid IID_ID2D1CommandSink3
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x35, 0x91, 0x07, 0x18,
+				0xF3, 0x4C,
+				0x68, 0x48,
+				0xBC,
+				0x8E,
+				0x06,
+				0x06,
+				0x7E,
+				0x6D,
+				0x24,
+				0x2D
+			};
+
+			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_ID2D1CommandSink3));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[3]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1GradientMesh*, int>)(lpVtbl[4]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[5]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, PrimitiveBlend, int>)(lpVtbl[6]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult BeginDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[7]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult EndDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[8]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, AntialiasMode, int>)(lpVtbl[9]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetTags(ulong tag1, ulong tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ulong, ulong, int>)(lpVtbl[10]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, TextAntialiasMode, int>)(lpVtbl[11]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[12]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult SetTransform(Matrix3x2* transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Matrix3x2*, int>)(lpVtbl[13]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, PrimitiveBlend, int>)(lpVtbl[14]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult SetUnitMode(UnitMode unitMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, UnitMode, int>)(lpVtbl[15]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult Clear(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Common.ColorF*, int>)(lpVtbl[16]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[17]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[18]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[19]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[20]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[21]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[22]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[23]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[24]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[25]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[26]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[27]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Common.RectF*, AntialiasMode, int>)(lpVtbl[28]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult PushLayer(LayerParameters1* layerParameters1, ID2D1Layer* layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[29]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), layerParameters1, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult PopAxisAlignedClip()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[30]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult PopLayer()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[31]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink3::DrawSpriteBatch"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, int>)(lpVtbl[32]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgGlyphStyle"]/*' />
+/// <unmanaged>ID2D1SvgGlyphStyle</unmanaged>
+[Guid("af671749-d241-4db8-8e41-dcc2e5c1a438")]
+[NativeTypeName("struct ID2D1SvgGlyphStyle : ID2D1Resource")]
+[NativeInheritance("ID2D1Resource")]
+public unsafe partial struct ID2D1SvgGlyphStyle
+{
+	public static ref readonly Guid IID_ID2D1SvgGlyphStyle
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x49, 0x17, 0x67, 0xAF,
+				0x41, 0xD2,
+				0xB8, 0x4D,
+				0x8E,
+				0x41,
+				0xDC,
+				0xC2,
+				0xE5,
+				0xC1,
+				0xA4,
+				0x38
+			};
+
+			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_ID2D1SvgGlyphStyle));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgGlyphStyle*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1SvgGlyphStyle*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgGlyphStyle::SetFill"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult SetFill(ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgGlyphStyle*, ID2D1Brush*, int>)(lpVtbl[4]))((ID2D1SvgGlyphStyle*)Unsafe.AsPointer(ref this), brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgGlyphStyle::GetFill"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void GetFill(ID2D1Brush** brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgGlyphStyle*, ID2D1Brush**, void>)(lpVtbl[5]))((ID2D1SvgGlyphStyle*)Unsafe.AsPointer(ref this), brush);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgGlyphStyle::SetStroke"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SetStroke(ID2D1Brush* brush, float strokeWidth, float* dashes, uint dashesCount, float dashOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgGlyphStyle*, ID2D1Brush*, float, float*, uint, float, int>)(lpVtbl[6]))((ID2D1SvgGlyphStyle*)Unsafe.AsPointer(ref this), brush, strokeWidth, dashes, dashesCount, dashOffset);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgGlyphStyle::GetStrokeDashesCount"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public uint GetStrokeDashesCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1SvgGlyphStyle*, uint>)(lpVtbl[7]))((ID2D1SvgGlyphStyle*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SvgGlyphStyle::GetStroke"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void GetStroke(ID2D1Brush** brush, float* strokeWidth, float* dashes, uint dashesCount, float* dashOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1SvgGlyphStyle*, ID2D1Brush**, float*, float*, uint, float*, void>)(lpVtbl[8]))((ID2D1SvgGlyphStyle*)Unsafe.AsPointer(ref this), brush, strokeWidth, dashes, dashesCount, dashOffset);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4"]/*' />
+/// <unmanaged>ID2D1DeviceContext4</unmanaged>
+[Guid("8c427831-3d90-4476-b647-c4fae349e4db")]
+[NativeTypeName("struct ID2D1DeviceContext4 : ID2D1DeviceContext3")]
+[NativeInheritance("ID2D1DeviceContext3")]
+public unsafe partial struct ID2D1DeviceContext4
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext4
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x31, 0x78, 0x42, 0x8C,
+				0x90, 0x3D,
+				0x76, 0x44,
+				0xB6,
+				0x47,
+				0xC4,
+				0xFA,
+				0xE3,
+				0x49,
+				0xE4,
+				0xDB
+			};
+
+			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_ID2D1DeviceContext4));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext3.CreateSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateSpriteBatch(ID2D1SpriteBatch** spriteBatch)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1SpriteBatch**, int>)(lpVtbl[3]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), spriteBatch);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext3.DrawSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, void>)(lpVtbl[4]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[5]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), startPoint, ink);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInkStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[6]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[7]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromWic" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateImageSourceFromWic(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, ImageSourceLoadingOptions loadingOptions, Common.AlphaMode alphaMode, ID2D1ImageSourceFromWic** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[8]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateLookupTable3D" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[9]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromDxgi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateImageSourceFromDxgi(Graphics.Dxgi.IDXGISurface** surfaces, uint surfaceCount, Graphics.Dxgi.Common.ColorSpaceType colorSpace, ImageSourceFromDxgiOptions options, ID2D1ImageSource** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[10]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.GetGradientMeshWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[11]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[12]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GradientMesh*, void>)(lpVtbl[13]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[14]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateTransformedImageSource" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[15]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[16]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateStrokedGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, float strokeWidth, ID2D1StrokeStyle* strokeStyle, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, float, float, ID2D1StrokeStyle*, ID2D1GeometryRealization**, int>)(lpVtbl[17]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[18]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometryRealization, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[19]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[20]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[21]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[22]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[23]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[24]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Guid*, ID2D1Effect**, int>)(lpVtbl[25]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[26]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[27]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[28]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1CommandList**, int>)(lpVtbl[29]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[30]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, BufferPrecision, Bool32>)(lpVtbl[31]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[32]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[33]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetGlyphRunWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[34]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Device**, void>)(lpVtbl[35]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, void>)(lpVtbl[36]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image**, void>)(lpVtbl[37]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RenderingControls*, void>)(lpVtbl[38]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RenderingControls*, void>)(lpVtbl[39]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, PrimitiveBlend, void>)(lpVtbl[40]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[41]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, UnitMode, void>)(lpVtbl[42]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Direct2D.UnitMode>)(lpVtbl[43]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[44]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[45]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[46]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[47]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[48]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[49]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, uint*, int>)(lpVtbl[50]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[51]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectRequiredInputRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[52]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[53]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[54]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[55]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[56]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[57]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[58]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[59]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[60]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[61]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[62]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[63]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Mesh**, int>)(lpVtbl[64]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[65]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[66]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[67]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[68]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[69]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[70]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[71]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[72]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[73]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[74]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[75]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[76]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[77]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[78]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[79]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Matrix3x2*, void>)(lpVtbl[80]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Matrix3x2**, void>)(lpVtbl[81]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, AntialiasMode, void>)(lpVtbl[82]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[83]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, TextAntialiasMode, void>)(lpVtbl[84]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[85]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[86]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[87]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong, ulong, void>)(lpVtbl[88]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong*, ulong*, void>)(lpVtbl[89]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[90]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, void>)(lpVtbl[91]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(92)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong*, ulong*, int>)(lpVtbl[92]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(93)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1DrawingStateBlock*, void>)(lpVtbl[93]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(94)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1DrawingStateBlock*, void>)(lpVtbl[94]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(95)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.RectF*, AntialiasMode, void>)(lpVtbl[95]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(96)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, void>)(lpVtbl[96]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(97)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.ColorF*, void>)(lpVtbl[97]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(98)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, void>)(lpVtbl[98]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(99)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong*, ulong*, int>)(lpVtbl[99]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(100)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[100]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(101)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, float, float, void>)(lpVtbl[101]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(102)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, float*, float*, void>)(lpVtbl[102]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(103)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.SizeF>)(lpVtbl[103]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(104)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[104]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(105)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, uint>)(lpVtbl[105]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(106)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RenderTargetProperties*, Bool32>)(lpVtbl[106]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(107)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Factory**, void>)(lpVtbl[107]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::CreateSvgGlyphStyle"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(108)]
+	public HResult CreateSvgGlyphStyle(ID2D1SvgGlyphStyle** svgGlyphStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1SvgGlyphStyle**, int>)(lpVtbl[108]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), svgGlyphStyle);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::DrawText"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(109)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[109]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options, measuringMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::DrawTextLayout"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(110)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, DrawTextOptions, void>)(lpVtbl[110]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::DrawColorBitmapGlyphRun"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(111)]
+	public void DrawColorBitmapGlyphRun(Graphics.DirectWrite.GlyphImageFormats glyphImageFormat, System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, ColorBitmapGlyphSnapOption bitmapSnapOption)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.DirectWrite.GlyphImageFormats, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, ColorBitmapGlyphSnapOption, void>)(lpVtbl[111]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), glyphImageFormat, baselineOrigin, glyphRun, measuringMode, bitmapSnapOption);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::DrawSvgGlyphRun"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(112)]
+	public void DrawSvgGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[112]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, measuringMode);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::GetColorBitmapGlyphImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(113)]
+	public HResult GetColorBitmapGlyphImage(Graphics.DirectWrite.GlyphImageFormats glyphImageFormat, System.Drawing.PointF* glyphOrigin, Graphics.DirectWrite.IDWriteFontFace* fontFace, float fontEmSize, ushort glyphIndex, Bool32 isSideways, Matrix3x2* worldTransform, float dpiX, float dpiY, Matrix3x2** glyphTransform, ID2D1Image** glyphImage)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.DirectWrite.GlyphImageFormats, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteFontFace*, float, ushort, Bool32, Matrix3x2*, float, float, Matrix3x2**, ID2D1Image**, int>)(lpVtbl[113]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), glyphImageFormat, glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, dpiX, dpiY, glyphTransform, glyphImage);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext4::GetSvgGlyphImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(114)]
+	public HResult GetSvgGlyphImage(System.Drawing.PointF* glyphOrigin, Graphics.DirectWrite.IDWriteFontFace* fontFace, float fontEmSize, ushort glyphIndex, Bool32 isSideways, Matrix3x2* worldTransform, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, Matrix3x2** glyphTransform, ID2D1CommandList** glyphImage)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteFontFace*, float, ushort, Bool32, Matrix3x2*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, Matrix3x2**, ID2D1CommandList**, int>)(lpVtbl[114]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, glyphTransform, glyphImage);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device4"]/*' />
+/// <unmanaged>ID2D1Device4</unmanaged>
+[Guid("d7bdb159-5683-4a46-bc9c-72dc720b858b")]
+[NativeTypeName("struct ID2D1Device4 : ID2D1Device3")]
+[NativeInheritance("ID2D1Device3")]
+public unsafe partial struct ID2D1Device4
+{
+	public static ref readonly Guid IID_ID2D1Device4
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x59, 0xB1, 0xBD, 0xD7,
+				0x83, 0x56,
+				0x46, 0x4A,
+				0xBC,
+				0x9C,
+				0x72,
+				0xDC,
+				0x72,
+				0x0B,
+				0x85,
+				0x8B
+			};
+
+			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_ID2D1Device4));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device3.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[3]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext3);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[4]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext2);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device4*, ID2D1Bitmap*, void>)(lpVtbl[5]))((ID2D1Device4*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[6]))((ID2D1Device4*)Unsafe.AsPointer(ref this), dxgiDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.RenderingPriority GetRenderingPriority()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, Graphics.Direct2D.RenderingPriority>)(lpVtbl[7]))((ID2D1Device4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void SetRenderingPriority(RenderingPriority renderingPriority)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device4*, RenderingPriority, void>)(lpVtbl[8]))((ID2D1Device4*)Unsafe.AsPointer(ref this), renderingPriority);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[9]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext1);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[10]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device4*, ulong, void>)(lpVtbl[11]))((ID2D1Device4*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, ulong>)(lpVtbl[12]))((ID2D1Device4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.ClearResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device4*, uint, void>)(lpVtbl[13]))((ID2D1Device4*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device4*, ID2D1Factory**, void>)(lpVtbl[14]))((ID2D1Device4*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device4::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext4** deviceContext4)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext4**, int>)(lpVtbl[15]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext4);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device4::SetMaximumColorGlyphCacheMemory"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void SetMaximumColorGlyphCacheMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device4*, ulong, void>)(lpVtbl[16]))((ID2D1Device4*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device4::GetMaximumColorGlyphCacheMemory"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public ulong GetMaximumColorGlyphCacheMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, ulong>)(lpVtbl[17]))((ID2D1Device4*)Unsafe.AsPointer(ref this));
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory5"]/*' />
+/// <unmanaged>ID2D1Factory5</unmanaged>
+[Guid("c4349994-838e-4b0f-8cab-44997d9eeacc")]
+[NativeTypeName("struct ID2D1Factory5 : ID2D1Factory4")]
+[NativeInheritance("ID2D1Factory4")]
+public unsafe partial struct ID2D1Factory5
+{
+	public static ref readonly Guid IID_ID2D1Factory5
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x94, 0x99, 0x34, 0xC4,
+				0x8E, 0x83,
+				0x0F, 0x4B,
+				0x8C,
+				0xAB,
+				0x44,
+				0x99,
+				0x7D,
+				0x9E,
+				0xEA,
+				0xCC
+			};
+
+			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_ID2D1Factory5));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory4.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[3]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[4]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[5]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[6]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[7]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, ID2D1PathGeometry1**, int>)(lpVtbl[8]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[9]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[10]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[11]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromString" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[12]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, int>)(lpVtbl[13]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, uint, uint*, uint*, int>)(lpVtbl[14]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, ID2D1Properties**, int>)(lpVtbl[15]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, int>)(lpVtbl[16]))((ID2D1Factory5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory5*, float*, float*, void>)(lpVtbl[17]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[18]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[19]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[20]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[21]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[22]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, ID2D1PathGeometry**, int>)(lpVtbl[23]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[24]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[25]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[26]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[27]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[28]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[29]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory5::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device4** d2dDevice4)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device4**, int>)(lpVtbl[30]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice4);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink4"]/*' />
+/// <unmanaged>ID2D1CommandSink4</unmanaged>
+[Guid("c78a6519-40d6-4218-b2de-beeeb744bb3e")]
+[NativeTypeName("struct ID2D1CommandSink4 : ID2D1CommandSink3")]
+[NativeInheritance("ID2D1CommandSink3")]
+public unsafe partial struct ID2D1CommandSink4
+{
+	public static ref readonly Guid IID_ID2D1CommandSink4
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x19, 0x65, 0x8A, 0xC7,
+				0xD6, 0x40,
+				0x18, 0x42,
+				0xB2,
+				0xDE,
+				0xBE,
+				0xEE,
+				0xB7,
+				0x44,
+				0xBB,
+				0x3E
+			};
+
+			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_ID2D1CommandSink4));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink3.DrawSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, int>)(lpVtbl[3]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[4]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1GradientMesh*, int>)(lpVtbl[5]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[6]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, PrimitiveBlend, int>)(lpVtbl[7]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult BeginDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[8]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult EndDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[9]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, AntialiasMode, int>)(lpVtbl[10]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetTags(ulong tag1, ulong tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ulong, ulong, int>)(lpVtbl[11]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, TextAntialiasMode, int>)(lpVtbl[12]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[13]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult SetTransform(Matrix3x2* transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Matrix3x2*, int>)(lpVtbl[14]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, PrimitiveBlend, int>)(lpVtbl[15]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult SetUnitMode(UnitMode unitMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, UnitMode, int>)(lpVtbl[16]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult Clear(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Common.ColorF*, int>)(lpVtbl[17]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[18]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[19]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[20]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[21]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[22]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[23]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[24]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[25]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[26]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[27]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[28]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Common.RectF*, AntialiasMode, int>)(lpVtbl[29]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult PushLayer(LayerParameters1* layerParameters1, ID2D1Layer* layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[30]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), layerParameters1, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult PopAxisAlignedClip()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[31]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult PopLayer()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[32]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink4::SetPrimitiveBlend2"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult SetPrimitiveBlend2(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, PrimitiveBlend, int>)(lpVtbl[33]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext1"]/*' />
+/// <unmanaged>ID2D1ColorContext1</unmanaged>
+[Guid("1ab42875-c57f-4be9-bd85-9cd78d6f55ee")]
+[NativeTypeName("struct ID2D1ColorContext1 : ID2D1ColorContext")]
+[NativeInheritance("ID2D1ColorContext")]
+public unsafe partial struct ID2D1ColorContext1
+{
+	public static ref readonly Guid IID_ID2D1ColorContext1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x75, 0x28, 0xB4, 0x1A,
+				0x7F, 0xC5,
+				0xE9, 0x4B,
+				0xBD,
+				0x85,
+				0x9C,
+				0xD7,
+				0x8D,
+				0x6F,
+				0x55,
+				0xEE
+			};
+
+			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_ID2D1ColorContext1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ColorContext.GetColorSpace" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public Graphics.Direct2D.ColorSpace GetColorSpace()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, Graphics.Direct2D.ColorSpace>)(lpVtbl[3]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ColorContext.GetProfileSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public uint GetProfileSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, uint>)(lpVtbl[4]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1ColorContext.GetProfile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetProfile(byte* profile, uint profileSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, byte*, uint, int>)(lpVtbl[5]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this), profile, profileSize);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, ID2D1Factory**, void>)(lpVtbl[6]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext1::GetColorContextType"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public Graphics.Direct2D.ColorContextType GetColorContextType()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, Graphics.Direct2D.ColorContextType>)(lpVtbl[7]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext1::GetDXGIColorSpace"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public Graphics.Dxgi.Common.ColorSpaceType GetDXGIColorSpace()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, Graphics.Dxgi.Common.ColorSpaceType>)(lpVtbl[8]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext1::GetSimpleColorProfile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult GetSimpleColorProfile(SimpleColorProfile* simpleProfile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, SimpleColorProfile*, int>)(lpVtbl[9]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this), simpleProfile);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext5"]/*' />
+/// <unmanaged>ID2D1DeviceContext5</unmanaged>
+[Guid("7836d248-68cc-4df6-b9e8-de991bf62eb7")]
+[NativeTypeName("struct ID2D1DeviceContext5 : ID2D1DeviceContext4")]
+[NativeInheritance("ID2D1DeviceContext4")]
+public unsafe partial struct ID2D1DeviceContext5
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext5
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x48, 0xD2, 0x36, 0x78,
+				0xCC, 0x68,
+				0xF6, 0x4D,
+				0xB9,
+				0xE8,
+				0xDE,
+				0x99,
+				0x1B,
+				0xF6,
+				0x2E,
+				0xB7
+			};
+
+			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_ID2D1DeviceContext5));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.CreateSvgGlyphStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateSvgGlyphStyle(ID2D1SvgGlyphStyle** svgGlyphStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1SvgGlyphStyle**, int>)(lpVtbl[3]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), svgGlyphStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[4]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, DrawTextOptions, void>)(lpVtbl[5]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawColorBitmapGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public void DrawColorBitmapGlyphRun(Graphics.DirectWrite.GlyphImageFormats glyphImageFormat, System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, ColorBitmapGlyphSnapOption bitmapSnapOption)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.DirectWrite.GlyphImageFormats, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, ColorBitmapGlyphSnapOption, void>)(lpVtbl[6]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), glyphImageFormat, baselineOrigin, glyphRun, measuringMode, bitmapSnapOption);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawSvgGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public void DrawSvgGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[7]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.GetColorBitmapGlyphImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult GetColorBitmapGlyphImage(Graphics.DirectWrite.GlyphImageFormats glyphImageFormat, System.Drawing.PointF* glyphOrigin, Graphics.DirectWrite.IDWriteFontFace* fontFace, float fontEmSize, ushort glyphIndex, Bool32 isSideways, Matrix3x2* worldTransform, float dpiX, float dpiY, Matrix3x2** glyphTransform, ID2D1Image** glyphImage)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.DirectWrite.GlyphImageFormats, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteFontFace*, float, ushort, Bool32, Matrix3x2*, float, float, Matrix3x2**, ID2D1Image**, int>)(lpVtbl[8]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), glyphImageFormat, glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, dpiX, dpiY, glyphTransform, glyphImage);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.GetSvgGlyphImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult GetSvgGlyphImage(System.Drawing.PointF* glyphOrigin, Graphics.DirectWrite.IDWriteFontFace* fontFace, float fontEmSize, ushort glyphIndex, Bool32 isSideways, Matrix3x2* worldTransform, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, Matrix3x2** glyphTransform, ID2D1CommandList** glyphImage)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteFontFace*, float, ushort, Bool32, Matrix3x2*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, Matrix3x2**, ID2D1CommandList**, int>)(lpVtbl[9]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, glyphTransform, glyphImage);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext3.CreateSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateSpriteBatch(ID2D1SpriteBatch** spriteBatch)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1SpriteBatch**, int>)(lpVtbl[10]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), spriteBatch);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext3.DrawSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, void>)(lpVtbl[11]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[12]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), startPoint, ink);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInkStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[13]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[14]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromWic" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateImageSourceFromWic(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, ImageSourceLoadingOptions loadingOptions, Common.AlphaMode alphaMode, ID2D1ImageSourceFromWic** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[15]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateLookupTable3D" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[16]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromDxgi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateImageSourceFromDxgi(Graphics.Dxgi.IDXGISurface** surfaces, uint surfaceCount, Graphics.Dxgi.Common.ColorSpaceType colorSpace, ImageSourceFromDxgiOptions options, ID2D1ImageSource** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[17]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.GetGradientMeshWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[18]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[19]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1GradientMesh*, void>)(lpVtbl[20]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[21]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateTransformedImageSource" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[22]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[23]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateStrokedGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, float strokeWidth, ID2D1StrokeStyle* strokeStyle, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Geometry*, float, float, ID2D1StrokeStyle*, ID2D1GeometryRealization**, int>)(lpVtbl[24]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[25]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), geometryRealization, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[26]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[27]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[28]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[29]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[30]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[31]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Guid*, ID2D1Effect**, int>)(lpVtbl[32]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[33]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[34]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[35]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1CommandList**, int>)(lpVtbl[36]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[37]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, BufferPrecision, Bool32>)(lpVtbl[38]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[39]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[40]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetGlyphRunWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[41]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Device**, void>)(lpVtbl[42]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Image*, void>)(lpVtbl[43]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Image**, void>)(lpVtbl[44]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, RenderingControls*, void>)(lpVtbl[45]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, RenderingControls*, void>)(lpVtbl[46]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, PrimitiveBlend, void>)(lpVtbl[47]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[48]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, UnitMode, void>)(lpVtbl[49]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Direct2D.UnitMode>)(lpVtbl[50]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[51]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[52]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[53]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[54]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[55]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[56]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Effect*, uint*, int>)(lpVtbl[57]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[58]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectRequiredInputRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[59]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[60]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[61]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[62]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[63]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[64]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[65]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[66]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[67]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[68]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[69]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[70]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Mesh**, int>)(lpVtbl[71]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[72]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[73]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[74]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[75]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[76]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[77]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[78]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[79]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[80]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[81]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[82]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[83]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[84]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[85]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[86]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Matrix3x2*, void>)(lpVtbl[87]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Matrix3x2**, void>)(lpVtbl[88]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, AntialiasMode, void>)(lpVtbl[89]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[90]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, TextAntialiasMode, void>)(lpVtbl[91]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(92)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[92]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(93)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[93]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(94)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[94]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(95)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ulong, ulong, void>)(lpVtbl[95]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(96)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ulong*, ulong*, void>)(lpVtbl[96]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(97)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[97]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(98)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, void>)(lpVtbl[98]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(99)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ulong*, ulong*, int>)(lpVtbl[99]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(100)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1DrawingStateBlock*, void>)(lpVtbl[100]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(101)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1DrawingStateBlock*, void>)(lpVtbl[101]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(102)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.RectF*, AntialiasMode, void>)(lpVtbl[102]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(103)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, void>)(lpVtbl[103]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(104)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Common.ColorF*, void>)(lpVtbl[104]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(105)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, void>)(lpVtbl[105]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(106)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ulong*, ulong*, int>)(lpVtbl[106]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(107)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[107]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(108)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, float, float, void>)(lpVtbl[108]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(109)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, float*, float*, void>)(lpVtbl[109]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(110)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, System.Drawing.SizeF>)(lpVtbl[110]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(111)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[111]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(112)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, uint>)(lpVtbl[112]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(113)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, RenderTargetProperties*, Bool32>)(lpVtbl[113]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(114)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1Factory**, void>)(lpVtbl[114]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext5::CreateSvgDocument"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(115)]
+	public HResult CreateSvgDocument(Com.IStream* inputXmlStream, System.Drawing.SizeF* viewportSize, ID2D1SvgDocument** svgDocument)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Com.IStream*, System.Drawing.SizeF*, ID2D1SvgDocument**, int>)(lpVtbl[115]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), inputXmlStream, viewportSize, svgDocument);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext5::DrawSvgDocument"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(116)]
+	public void DrawSvgDocument(ID2D1SvgDocument* svgDocument)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, ID2D1SvgDocument*, void>)(lpVtbl[116]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), svgDocument);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext5::CreateColorContextFromDxgiColorSpace"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(117)]
+	public HResult CreateColorContextFromDxgiColorSpace(Graphics.Dxgi.Common.ColorSpaceType colorSpace, ID2D1ColorContext1** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, Graphics.Dxgi.Common.ColorSpaceType, ID2D1ColorContext1**, int>)(lpVtbl[117]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), colorSpace, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext5::CreateColorContextFromSimpleColorProfile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(118)]
+	public HResult CreateColorContextFromSimpleColorProfile(SimpleColorProfile* simpleProfile, ID2D1ColorContext1** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext5*, SimpleColorProfile*, ID2D1ColorContext1**, int>)(lpVtbl[118]))((ID2D1DeviceContext5*)Unsafe.AsPointer(ref this), simpleProfile, colorContext);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device5"]/*' />
+/// <unmanaged>ID2D1Device5</unmanaged>
+[Guid("d55ba0a4-6405-4694-aef5-08ee1a4358b4")]
+[NativeTypeName("struct ID2D1Device5 : ID2D1Device4")]
+[NativeInheritance("ID2D1Device4")]
+public unsafe partial struct ID2D1Device5
+{
+	public static ref readonly Guid IID_ID2D1Device5
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA4, 0xA0, 0x5B, 0xD5,
+				0x05, 0x64,
+				0x94, 0x46,
+				0xAE,
+				0xF5,
+				0x08,
+				0xEE,
+				0x1A,
+				0x43,
+				0x58,
+				0xB4
+			};
+
+			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_ID2D1Device5));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device4.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext4** deviceContext4)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext4**, int>)(lpVtbl[3]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext4);
+	}
+
+	/// <inheritdoc cref="ID2D1Device4.SetMaximumColorGlyphCacheMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void SetMaximumColorGlyphCacheMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong, void>)(lpVtbl[4]))((ID2D1Device5*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device4.GetMaximumColorGlyphCacheMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public ulong GetMaximumColorGlyphCacheMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong>)(lpVtbl[5]))((ID2D1Device5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device3.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[6]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext3);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[7]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext2);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device5*, ID2D1Bitmap*, void>)(lpVtbl[8]))((ID2D1Device5*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[9]))((ID2D1Device5*)Unsafe.AsPointer(ref this), dxgiDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public Graphics.Direct2D.RenderingPriority GetRenderingPriority()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, Graphics.Direct2D.RenderingPriority>)(lpVtbl[10]))((ID2D1Device5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void SetRenderingPriority(RenderingPriority renderingPriority)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device5*, RenderingPriority, void>)(lpVtbl[11]))((ID2D1Device5*)Unsafe.AsPointer(ref this), renderingPriority);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[12]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext1);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[13]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong, void>)(lpVtbl[14]))((ID2D1Device5*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong>)(lpVtbl[15]))((ID2D1Device5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.ClearResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device5*, uint, void>)(lpVtbl[16]))((ID2D1Device5*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device5*, ID2D1Factory**, void>)(lpVtbl[17]))((ID2D1Device5*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device5::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext5** deviceContext5)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext5**, int>)(lpVtbl[18]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext5);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory6"]/*' />
+/// <unmanaged>ID2D1Factory6</unmanaged>
+[Guid("f9976f46-f642-44c1-97ca-da32ea2a2635")]
+[NativeTypeName("struct ID2D1Factory6 : ID2D1Factory5")]
+[NativeInheritance("ID2D1Factory5")]
+public unsafe partial struct ID2D1Factory6
+{
+	public static ref readonly Guid IID_ID2D1Factory6
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x46, 0x6F, 0x97, 0xF9,
+				0x42, 0xF6,
+				0xC1, 0x44,
+				0x97,
+				0xCA,
+				0xDA,
+				0x32,
+				0xEA,
+				0x2A,
+				0x26,
+				0x35
+			};
+
+			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_ID2D1Factory6));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory5.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device4** d2dDevice4)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device4**, int>)(lpVtbl[3]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice4);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory4.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[4]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[5]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[6]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[7]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[8]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, ID2D1PathGeometry1**, int>)(lpVtbl[9]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[10]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[11]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[12]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromString" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[13]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, int>)(lpVtbl[14]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, uint, uint*, uint*, int>)(lpVtbl[15]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, ID2D1Properties**, int>)(lpVtbl[16]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, int>)(lpVtbl[17]))((ID2D1Factory6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory6*, float*, float*, void>)(lpVtbl[18]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[19]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[20]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[21]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[22]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[23]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, ID2D1PathGeometry**, int>)(lpVtbl[24]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[25]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[26]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[27]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[28]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[29]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[30]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory6::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device5** d2dDevice5)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device5**, int>)(lpVtbl[31]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice5);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink5"]/*' />
+/// <unmanaged>ID2D1CommandSink5</unmanaged>
+[Guid("7047dd26-b1e7-44a7-959a-8349e2144fa8")]
+[NativeTypeName("struct ID2D1CommandSink5 : ID2D1CommandSink4")]
+[NativeInheritance("ID2D1CommandSink4")]
+public unsafe partial struct ID2D1CommandSink5
+{
+	public static ref readonly Guid IID_ID2D1CommandSink5
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x26, 0xDD, 0x47, 0x70,
+				0xE7, 0xB1,
+				0xA7, 0x44,
+				0x95,
+				0x9A,
+				0x83,
+				0x49,
+				0xE2,
+				0x14,
+				0x4F,
+				0xA8
+			};
+
+			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_ID2D1CommandSink5));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink4.SetPrimitiveBlend2" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetPrimitiveBlend2(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, PrimitiveBlend, int>)(lpVtbl[3]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink3.DrawSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, int>)(lpVtbl[4]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[5]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1GradientMesh*, int>)(lpVtbl[6]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[7]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, PrimitiveBlend, int>)(lpVtbl[8]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult BeginDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[9]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult EndDraw()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[10]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, AntialiasMode, int>)(lpVtbl[11]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult SetTags(ulong tag1, ulong tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ulong, ulong, int>)(lpVtbl[12]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, TextAntialiasMode, int>)(lpVtbl[13]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[14]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult SetTransform(Matrix3x2* transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Matrix3x2*, int>)(lpVtbl[15]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, PrimitiveBlend, int>)(lpVtbl[16]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult SetUnitMode(UnitMode unitMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, UnitMode, int>)(lpVtbl[17]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult Clear(Common.ColorF* color)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Common.ColorF*, int>)(lpVtbl[18]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), color);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[19]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[20]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[21]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[22]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[23]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[24]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[25]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[26]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[27]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[28]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[29]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Common.RectF*, AntialiasMode, int>)(lpVtbl[30]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult PushLayer(LayerParameters1* layerParameters1, ID2D1Layer* layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[31]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), layerParameters1, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult PopAxisAlignedClip()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[32]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult PopLayer()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[33]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1CommandSink5::BlendImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public HResult BlendImage(ID2D1Image* image, Common.BlendMode blendMode, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Image*, Common.BlendMode, System.Drawing.PointF*, Common.RectF*, InterpolationMode, int>)(lpVtbl[34]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), image, blendMode, targetOffset, imageRectangle, interpolationMode);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext6"]/*' />
+/// <unmanaged>ID2D1DeviceContext6</unmanaged>
+[Guid("985f7e37-4ed0-4a19-98a3-15b0edfde306")]
+[NativeTypeName("struct ID2D1DeviceContext6 : ID2D1DeviceContext5")]
+[NativeInheritance("ID2D1DeviceContext5")]
+public unsafe partial struct ID2D1DeviceContext6
+{
+	public static ref readonly Guid IID_ID2D1DeviceContext6
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x37, 0x7E, 0x5F, 0x98,
+				0xD0, 0x4E,
+				0x19, 0x4A,
+				0x98,
+				0xA3,
+				0x15,
+				0xB0,
+				0xED,
+				0xFD,
+				0xE3,
+				0x06
+			};
+
+			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_ID2D1DeviceContext6));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext5.CreateSvgDocument" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateSvgDocument(Com.IStream* inputXmlStream, System.Drawing.SizeF* viewportSize, ID2D1SvgDocument** svgDocument)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Com.IStream*, System.Drawing.SizeF*, ID2D1SvgDocument**, int>)(lpVtbl[3]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), inputXmlStream, viewportSize, svgDocument);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext5.DrawSvgDocument" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void DrawSvgDocument(ID2D1SvgDocument* svgDocument)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1SvgDocument*, void>)(lpVtbl[4]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), svgDocument);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext5.CreateColorContextFromDxgiColorSpace" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateColorContextFromDxgiColorSpace(Graphics.Dxgi.Common.ColorSpaceType colorSpace, ID2D1ColorContext1** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Dxgi.Common.ColorSpaceType, ID2D1ColorContext1**, int>)(lpVtbl[5]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), colorSpace, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext5.CreateColorContextFromSimpleColorProfile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateColorContextFromSimpleColorProfile(SimpleColorProfile* simpleProfile, ID2D1ColorContext1** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, SimpleColorProfile*, ID2D1ColorContext1**, int>)(lpVtbl[6]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), simpleProfile, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.CreateSvgGlyphStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateSvgGlyphStyle(ID2D1SvgGlyphStyle** svgGlyphStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1SvgGlyphStyle**, int>)(lpVtbl[7]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), svgGlyphStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[8]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, DrawTextOptions, void>)(lpVtbl[9]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawColorBitmapGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public void DrawColorBitmapGlyphRun(Graphics.DirectWrite.GlyphImageFormats glyphImageFormat, System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, ColorBitmapGlyphSnapOption bitmapSnapOption)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.DirectWrite.GlyphImageFormats, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, ColorBitmapGlyphSnapOption, void>)(lpVtbl[10]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), glyphImageFormat, baselineOrigin, glyphRun, measuringMode, bitmapSnapOption);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.DrawSvgGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public void DrawSvgGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[11]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.GetColorBitmapGlyphImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult GetColorBitmapGlyphImage(Graphics.DirectWrite.GlyphImageFormats glyphImageFormat, System.Drawing.PointF* glyphOrigin, Graphics.DirectWrite.IDWriteFontFace* fontFace, float fontEmSize, ushort glyphIndex, Bool32 isSideways, Matrix3x2* worldTransform, float dpiX, float dpiY, Matrix3x2** glyphTransform, ID2D1Image** glyphImage)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.DirectWrite.GlyphImageFormats, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteFontFace*, float, ushort, Bool32, Matrix3x2*, float, float, Matrix3x2**, ID2D1Image**, int>)(lpVtbl[12]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), glyphImageFormat, glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, dpiX, dpiY, glyphTransform, glyphImage);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext4.GetSvgGlyphImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetSvgGlyphImage(System.Drawing.PointF* glyphOrigin, Graphics.DirectWrite.IDWriteFontFace* fontFace, float fontEmSize, ushort glyphIndex, Bool32 isSideways, Matrix3x2* worldTransform, ID2D1Brush* defaultFillBrush, ID2D1SvgGlyphStyle* svgGlyphStyle, uint colorPaletteIndex, Matrix3x2** glyphTransform, ID2D1CommandList** glyphImage)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteFontFace*, float, ushort, Bool32, Matrix3x2*, ID2D1Brush*, ID2D1SvgGlyphStyle*, uint, Matrix3x2**, ID2D1CommandList**, int>)(lpVtbl[13]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, glyphTransform, glyphImage);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext3.CreateSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateSpriteBatch(ID2D1SpriteBatch** spriteBatch)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1SpriteBatch**, int>)(lpVtbl[14]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), spriteBatch);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext3.DrawSpriteBatch" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void DrawSpriteBatch(ID2D1SpriteBatch* spriteBatch, uint startIndex, uint spriteCount, ID2D1Bitmap* bitmap, BitmapInterpolationMode interpolationMode, SpriteOptions spriteOptions)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, void>)(lpVtbl[15]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[16]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), startPoint, ink);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateInkStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[17]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[18]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromWic" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateImageSourceFromWic(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, ImageSourceLoadingOptions loadingOptions, Common.AlphaMode alphaMode, ID2D1ImageSourceFromWic** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[19]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateLookupTable3D" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[20]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateImageSourceFromDxgi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateImageSourceFromDxgi(Graphics.Dxgi.IDXGISurface** surfaces, uint surfaceCount, Graphics.Dxgi.Common.ColorSpaceType colorSpace, ImageSourceFromDxgiOptions options, ID2D1ImageSource** imageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[21]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.GetGradientMeshWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[22]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawInk" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[23]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGradientMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1GradientMesh*, void>)(lpVtbl[24]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), gradientMesh);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext2.CreateTransformedImageSource" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[26]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[27]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateStrokedGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, float strokeWidth, ID2D1StrokeStyle* strokeStyle, ID2D1GeometryRealization** geometryRealization)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Geometry*, float, float, ID2D1StrokeStyle*, ID2D1GeometryRealization**, int>)(lpVtbl[28]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[29]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), geometryRealization, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult CreateBitmap(Common.SizeU* size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.SizeU*, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[30]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[31]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[32]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(33)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[33]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(34)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[34]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(35)]
+	public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[35]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(36)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Guid*, ID2D1Effect**, int>)(lpVtbl[36]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(37)]
+	public HResult CreateGradientStopCollection(GradientStop* straightAlphaGradientStops, uint straightAlphaGradientStopsCount, ColorSpace preInterpolationSpace, ColorSpace postInterpolationSpace, BufferPrecision bufferPrecision, ExtendMode extendMode, ColorInterpolationMode colorInterpolationMode, ID2D1GradientStopCollection1** gradientStopCollection1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[37]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(38)]
+	public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[38]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(39)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[39]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(40)]
+	public HResult CreateCommandList(ID2D1CommandList** commandList)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1CommandList**, int>)(lpVtbl[40]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), commandList);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(41)]
+	public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[41]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), format);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(42)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, BufferPrecision, Bool32>)(lpVtbl[42]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(43)]
+	public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[43]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image, localBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(44)]
+	public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[44]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image, worldBounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetGlyphRunWorldBounds" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(45)]
+	public HResult GetGlyphRunWorldBounds(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.MeasuringMode measuringMode, Common.RectF* bounds)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[45]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(46)]
+	public void GetDevice(ID2D1Device** device)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Device**, void>)(lpVtbl[46]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), device);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(47)]
+	public void SetTarget(ID2D1Image* image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image*, void>)(lpVtbl[47]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(48)]
+	public void GetTarget(ID2D1Image** image)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image**, void>)(lpVtbl[48]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(49)]
+	public void SetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, RenderingControls*, void>)(lpVtbl[49]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(50)]
+	public void GetRenderingControls(RenderingControls* renderingControls)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, RenderingControls*, void>)(lpVtbl[50]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), renderingControls);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(51)]
+	public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, PrimitiveBlend, void>)(lpVtbl[51]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), primitiveBlend);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(52)]
+	public Graphics.Direct2D.PrimitiveBlend GetPrimitiveBlend()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Direct2D.PrimitiveBlend>)(lpVtbl[52]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(53)]
+	public void SetUnitMode(UnitMode unitMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, UnitMode, void>)(lpVtbl[53]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), unitMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(54)]
+	public Graphics.Direct2D.UnitMode GetUnitMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Direct2D.UnitMode>)(lpVtbl[54]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(55)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, Graphics.DirectWrite.GlyphRunDescription* glyphRunDescription, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[55]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawImage" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(56)]
+	public void DrawImage(ID2D1Image* image, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode, Common.CompositeMode compositeMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[56]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(57)]
+	public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[57]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(58)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, InterpolationMode interpolationMode, Common.RectF* sourceRectangle, Matrix4x4* perspectiveTransform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[58]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(59)]
+	public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[59]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(60)]
+	public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[60]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(61)]
+	public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Effect*, uint*, int>)(lpVtbl[61]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), effect, rectangleCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(62)]
+	public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[62]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.GetEffectRequiredInputRectangles" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(63)]
+	public HResult GetEffectRequiredInputRectangles(ID2D1Effect* renderEffect, Common.RectF* renderImageRectangle, EffectInputDescription* inputDescriptions, Common.RectF* requiredInputRects, uint inputCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[63]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
+	}
+
+	/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(64)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, void>)(lpVtbl[64]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(65)]
+	public HResult CreateBitmap(Common.SizeU* size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.SizeU*, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[65]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(66)]
+	public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[66]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(67)]
+	public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[67]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(68)]
+	public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[68]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(69)]
+	public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[69]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(70)]
+	public HResult CreateGradientStopCollection(GradientStop* gradientStops, uint gradientStopsCount, Gamma colorInterpolationGamma, ExtendMode extendMode, ID2D1GradientStopCollection** gradientStopCollection)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, GradientStop*, uint, Gamma, ExtendMode, ID2D1GradientStopCollection**, int>)(lpVtbl[70]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(71)]
+	public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[71]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(72)]
+	public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[72]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(73)]
+	public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, Common.SizeU* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.SizeF*, Common.SizeU*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[73]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(74)]
+	public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[74]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), size, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(75)]
+	public HResult CreateMesh(ID2D1Mesh** mesh)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Mesh**, int>)(lpVtbl[75]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), mesh);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawLine" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(76)]
+	public void DrawLine(System.Drawing.PointF* point0, System.Drawing.PointF* point1, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[76]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(77)]
+	public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[77]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(78)]
+	public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[78]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), rect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(79)]
+	public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[79]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(80)]
+	public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[80]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), roundedRect, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(81)]
+	public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[81]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(82)]
+	public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[82]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), ellipse, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(83)]
+	public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[83]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(84)]
+	public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[84]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(85)]
+	public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[85]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), mesh, brush);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.FillOpacityMask" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(86)]
+	public void FillOpacityMask(ID2D1Bitmap* opacityMask, ID2D1Brush* brush, OpacityMaskContent content, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[86]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(87)]
+	public void DrawBitmap(ID2D1Bitmap* bitmap, Common.RectF* destinationRectangle, float opacity, BitmapInterpolationMode interpolationMode, Common.RectF* sourceRectangle)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[87]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawText" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(88)]
+	public void DrawText(ushort* @string, uint stringLength, Graphics.DirectWrite.IDWriteTextFormat* textFormat, Common.RectF* layoutRect, ID2D1Brush* defaultFillBrush, DrawTextOptions options, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[88]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawTextLayout" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(89)]
+	public void DrawTextLayout(System.Drawing.PointF* origin, Graphics.DirectWrite.IDWriteTextLayout* textLayout, ID2D1Brush* defaultFillBrush, DrawTextOptions options)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[89]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.DrawGlyphRun" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(90)]
+	public void DrawGlyphRun(System.Drawing.PointF* baselineOrigin, Graphics.DirectWrite.GlyphRun* glyphRun, ID2D1Brush* foregroundBrush, Graphics.DirectWrite.MeasuringMode measuringMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[90]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(91)]
+	public void SetTransform(Matrix3x2* transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Matrix3x2*, void>)(lpVtbl[91]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(92)]
+	public void GetTransform(Matrix3x2** transform)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Matrix3x2**, void>)(lpVtbl[92]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), transform);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(93)]
+	public void SetAntialiasMode(AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, AntialiasMode, void>)(lpVtbl[93]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(94)]
+	public Graphics.Direct2D.AntialiasMode GetAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Direct2D.AntialiasMode>)(lpVtbl[94]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(95)]
+	public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, TextAntialiasMode, void>)(lpVtbl[95]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), textAntialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(96)]
+	public Graphics.Direct2D.TextAntialiasMode GetTextAntialiasMode()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Direct2D.TextAntialiasMode>)(lpVtbl[96]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(97)]
+	public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[97]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(98)]
+	public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[98]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), textRenderingParams);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(99)]
+	public void SetTags(ulong tag1, ulong tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ulong, ulong, void>)(lpVtbl[99]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(100)]
+	public void GetTags(ulong* tag1, ulong* tag2)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ulong*, ulong*, void>)(lpVtbl[100]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(101)]
+	public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[101]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), layerParameters, layer);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(102)]
+	public void PopLayer()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, void>)(lpVtbl[102]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(103)]
+	public HResult Flush(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ulong*, ulong*, int>)(lpVtbl[103]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(104)]
+	public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1DrawingStateBlock*, void>)(lpVtbl[104]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(105)]
+	public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1DrawingStateBlock*, void>)(lpVtbl[105]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(106)]
+	public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.RectF*, AntialiasMode, void>)(lpVtbl[106]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(107)]
+	public void PopAxisAlignedClip()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, void>)(lpVtbl[107]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(108)]
+	public void Clear(Common.ColorF* clearColor)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Common.ColorF*, void>)(lpVtbl[108]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), clearColor);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(109)]
+	public void BeginDraw()
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, void>)(lpVtbl[109]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(110)]
+	public HResult EndDraw(ulong* tag1, ulong* tag2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ulong*, ulong*, int>)(lpVtbl[110]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), tag1, tag2);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(111)]
+	public Graphics.Direct2D.Common.PixelFormat GetPixelFormat()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Direct2D.Common.PixelFormat>)(lpVtbl[111]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(112)]
+	public void SetDpi(float dpiX, float dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, float, float, void>)(lpVtbl[112]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(113)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, float*, float*, void>)(lpVtbl[113]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(114)]
+	public System.Drawing.SizeF GetSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, System.Drawing.SizeF>)(lpVtbl[114]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(115)]
+	public Graphics.Direct2D.Common.SizeU GetPixelSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, Graphics.Direct2D.Common.SizeU>)(lpVtbl[115]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(116)]
+	public uint GetMaximumBitmapSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, uint>)(lpVtbl[116]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(117)]
+	public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, RenderTargetProperties*, Bool32>)(lpVtbl[117]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), renderTargetProperties);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(118)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Factory**, void>)(lpVtbl[118]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext6::BlendImage"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(119)]
+	public void BlendImage(ID2D1Image* image, Common.BlendMode blendMode, System.Drawing.PointF* targetOffset, Common.RectF* imageRectangle, InterpolationMode interpolationMode)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1DeviceContext6*, ID2D1Image*, Common.BlendMode, System.Drawing.PointF*, Common.RectF*, InterpolationMode, void>)(lpVtbl[119]))((ID2D1DeviceContext6*)Unsafe.AsPointer(ref this), image, blendMode, targetOffset, imageRectangle, interpolationMode);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device6"]/*' />
+/// <unmanaged>ID2D1Device6</unmanaged>
+[Guid("7bfef914-2d75-4bad-be87-e18ddb077b6d")]
+[NativeTypeName("struct ID2D1Device6 : ID2D1Device5")]
+[NativeInheritance("ID2D1Device5")]
+public unsafe partial struct ID2D1Device6
+{
+	public static ref readonly Guid IID_ID2D1Device6
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x14, 0xF9, 0xFE, 0x7B,
+				0x75, 0x2D,
+				0xAD, 0x4B,
+				0xBE,
+				0x87,
+				0xE1,
+				0x8D,
+				0xDB,
+				0x07,
+				0x7B,
+				0x6D
+			};
+
+			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_ID2D1Device6));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device5.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext5** deviceContext5)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext5**, int>)(lpVtbl[3]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext5);
+	}
+
+	/// <inheritdoc cref="ID2D1Device4.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext4** deviceContext4)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext4**, int>)(lpVtbl[4]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext4);
+	}
+
+	/// <inheritdoc cref="ID2D1Device4.SetMaximumColorGlyphCacheMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public void SetMaximumColorGlyphCacheMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong, void>)(lpVtbl[5]))((ID2D1Device6*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device4.GetMaximumColorGlyphCacheMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public ulong GetMaximumColorGlyphCacheMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong>)(lpVtbl[6]))((ID2D1Device6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device3.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[7]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext3);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[8]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext2);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device6*, ID2D1Bitmap*, void>)(lpVtbl[9]))((ID2D1Device6*)Unsafe.AsPointer(ref this), bitmap);
+	}
+
+	/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[10]))((ID2D1Device6*)Unsafe.AsPointer(ref this), dxgiDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public Graphics.Direct2D.RenderingPriority GetRenderingPriority()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, Graphics.Direct2D.RenderingPriority>)(lpVtbl[11]))((ID2D1Device6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public void SetRenderingPriority(RenderingPriority renderingPriority)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device6*, RenderingPriority, void>)(lpVtbl[12]))((ID2D1Device6*)Unsafe.AsPointer(ref this), renderingPriority);
+	}
+
+	/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[13]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext1);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[14]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public void SetMaximumTextureMemory(ulong maximumInBytes)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong, void>)(lpVtbl[15]))((ID2D1Device6*)Unsafe.AsPointer(ref this), maximumInBytes);
+	}
+
+	/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public ulong GetMaximumTextureMemory()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong>)(lpVtbl[16]))((ID2D1Device6*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Device.ClearResources" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public void ClearResources(uint millisecondsSinceUse)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device6*, uint, void>)(lpVtbl[17]))((ID2D1Device6*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
+	}
+
+	/// <inheritdoc cref="ID2D1Resource.GetFactory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public void GetFactory(ID2D1Factory** factory)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Device6*, ID2D1Factory**, void>)(lpVtbl[18]))((ID2D1Device6*)Unsafe.AsPointer(ref this), factory);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Device6::CreateDeviceContext"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext6** deviceContext6)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext6**, int>)(lpVtbl[19]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext6);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory7"]/*' />
+/// <unmanaged>ID2D1Factory7</unmanaged>
+[Guid("bdc2bdd3-b96c-4de6-bdf7-99d4745454de")]
+[NativeTypeName("struct ID2D1Factory7 : ID2D1Factory6")]
+[NativeInheritance("ID2D1Factory6")]
+public unsafe partial struct ID2D1Factory7
+{
+	public static ref readonly Guid IID_ID2D1Factory7
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xD3, 0xBD, 0xC2, 0xBD,
+				0x6C, 0xB9,
+				0xE6, 0x4D,
+				0xBD,
+				0xF7,
+				0x99,
+				0xD4,
+				0x74,
+				0x54,
+				0x54,
+				0xDE
+			};
+
+			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_ID2D1Factory7));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory6.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device5** d2dDevice5)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device5**, int>)(lpVtbl[3]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice5);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory5.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device4** d2dDevice4)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device4**, int>)(lpVtbl[4]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice4);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory4.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[5]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[6]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[7]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[8]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[9]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, ID2D1PathGeometry1**, int>)(lpVtbl[10]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[11]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[12]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), metafileStream, metafile);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult RegisterEffectFromStream(Guid* classId, Com.IStream* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[13]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.RegisterEffectFromString" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult RegisterEffectFromString(Guid* classId, ushort* propertyXml, PropertyBinding* bindings, uint bindingsCount, delegate* unmanaged[Stdcall]<void*, void> effectFactory)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[14]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult UnregisterEffect(Guid* classId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, int>)(lpVtbl[15]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), classId);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, uint, uint*, uint*, int>)(lpVtbl[16]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, ID2D1Properties**, int>)(lpVtbl[17]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), effectId, properties);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.ReloadSystemMetrics" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult ReloadSystemMetrics()
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, int>)(lpVtbl[18]))((ID2D1Factory7*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public void GetDesktopDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1Factory7*, float*, float*, void>)(lpVtbl[19]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateRectangleGeometry(Common.RectF* rectangle, ID2D1RectangleGeometry** rectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[20]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), rectangle, rectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateRoundedRectangleGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateRoundedRectangleGeometry(RoundedRect* roundedRectangle, ID2D1RoundedRectangleGeometry** roundedRectangleGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[21]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), roundedRectangle, roundedRectangleGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateEllipseGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateEllipseGeometry(Ellipse* ellipse, ID2D1EllipseGeometry** ellipseGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[22]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), ellipse, ellipseGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateGeometryGroup" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateGeometryGroup(Common.FillMode fillMode, ID2D1Geometry** geometries, uint geometriesCount, ID2D1GeometryGroup** geometryGroup)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[23]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), fillMode, geometries, geometriesCount, geometryGroup);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateTransformedGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateTransformedGeometry(ID2D1Geometry* sourceGeometry, Matrix3x2* transform, ID2D1TransformedGeometry** transformedGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[24]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), sourceGeometry, transform, transformedGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreatePathGeometry" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreatePathGeometry(ID2D1PathGeometry** pathGeometry)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, ID2D1PathGeometry**, int>)(lpVtbl[25]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), pathGeometry);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateStrokeStyle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateStrokeStyle(StrokeStyleProperties* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle** strokeStyle)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[26]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDrawingStateBlock" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(27)]
+	public HResult CreateDrawingStateBlock(DrawingStateDescription* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock** drawingStateBlock)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[27]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateWicBitmapRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(28)]
+	public HResult CreateWicBitmapRenderTarget(Graphics.Imaging.IWICBitmap* target, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[28]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), target, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateHwndRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(29)]
+	public HResult CreateHwndRenderTarget(RenderTargetProperties* renderTargetProperties, HwndRenderTargetProperties* hwndRenderTargetProperties, ID2D1HwndRenderTarget** hwndRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[29]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDxgiSurfaceRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(30)]
+	public HResult CreateDxgiSurfaceRenderTarget(Graphics.Dxgi.IDXGISurface* dxgiSurface, RenderTargetProperties* renderTargetProperties, ID2D1RenderTarget** renderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[30]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiSurface, renderTargetProperties, renderTarget);
+	}
+
+	/// <inheritdoc cref="ID2D1Factory.CreateDCRenderTarget" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(31)]
+	public HResult CreateDCRenderTarget(RenderTargetProperties* renderTargetProperties, ID2D1DCRenderTarget** dcRenderTarget)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[31]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1Factory7::CreateDevice"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(32)]
+	public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device6** d2dDevice6)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device6**, int>)(lpVtbl[32]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice6);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext1"]/*' />
+/// <unmanaged>ID2D1EffectContext1</unmanaged>
+[Guid("84ab595a-fc81-4546-bacd-e8ef4d8abe7a")]
+[NativeTypeName("struct ID2D1EffectContext1 : ID2D1EffectContext")]
+[NativeInheritance("ID2D1EffectContext")]
+public unsafe partial struct ID2D1EffectContext1
+{
+	public static ref readonly Guid IID_ID2D1EffectContext1
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x5A, 0x59, 0xAB, 0x84,
+				0x81, 0xFC,
+				0x46, 0x45,
+				0xBA,
+				0xCD,
+				0xE8,
+				0xEF,
+				0x4D,
+				0x8A,
+				0xBE,
+				0x7A
+			};
+
+			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_ID2D1EffectContext1));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, float*, float*, void>)(lpVtbl[3]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, ID2D1Effect**, int>)(lpVtbl[4]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.GetMaximumSupportedFeatureLevel" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetMaximumSupportedFeatureLevel(Graphics.Direct3D.FeatureLevel* featureLevels, uint featureLevelsCount, Graphics.Direct3D.FeatureLevel* maximumSupportedFeatureLevel)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Graphics.Direct3D.FeatureLevel*, uint, Graphics.Direct3D.FeatureLevel*, int>)(lpVtbl[5]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), featureLevels, featureLevelsCount, maximumSupportedFeatureLevel);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateTransformNodeFromEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreateTransformNodeFromEffect(ID2D1Effect* effect, ID2D1TransformNode** transformNode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, ID2D1Effect*, ID2D1TransformNode**, int>)(lpVtbl[6]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), effect, transformNode);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateBlendTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateBlendTransform(uint numInputs, BlendDescription* blendDescription, ID2D1BlendTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, uint, BlendDescription*, ID2D1BlendTransform**, int>)(lpVtbl[7]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), numInputs, blendDescription, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateBorderTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateBorderTransform(ExtendMode extendModeX, ExtendMode extendModeY, ID2D1BorderTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, ExtendMode, ExtendMode, ID2D1BorderTransform**, int>)(lpVtbl[8]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), extendModeX, extendModeY, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateOffsetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateOffsetTransform(System.Drawing.Point* offset, ID2D1OffsetTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, System.Drawing.Point*, ID2D1OffsetTransform**, int>)(lpVtbl[9]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), offset, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateBoundsAdjustmentTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateBoundsAdjustmentTransform(RawRect* outputRectangle, ID2D1BoundsAdjustmentTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, RawRect*, ID2D1BoundsAdjustmentTransform**, int>)(lpVtbl[10]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), outputRectangle, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.LoadPixelShader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult LoadPixelShader(Guid* shaderId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, byte*, uint, int>)(lpVtbl[11]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), shaderId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.LoadVertexShader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult LoadVertexShader(Guid* resourceId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, byte*, uint, int>)(lpVtbl[12]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), resourceId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.LoadComputeShader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult LoadComputeShader(Guid* resourceId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, byte*, uint, int>)(lpVtbl[13]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), resourceId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.IsShaderLoaded" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public Bool32 IsShaderLoaded(Guid* shaderId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, Bool32>)(lpVtbl[14]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), shaderId);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateResourceTexture" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateResourceTexture(Guid* resourceId, ResourceTextureProperties* resourceTextureProperties, byte* data, uint* strides, uint dataSize, ID2D1ResourceTexture** resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, ResourceTextureProperties*, byte*, uint*, uint, ID2D1ResourceTexture**, int>)(lpVtbl[15]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), resourceId, resourceTextureProperties, data, strides, dataSize, resourceTexture);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.FindResourceTexture" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult FindResourceTexture(Guid* resourceId, ID2D1ResourceTexture** resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, ID2D1ResourceTexture**, int>)(lpVtbl[16]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), resourceId, resourceTexture);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateVertexBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateVertexBuffer(VertexBufferProperties* vertexBufferProperties, Guid* resourceId, CustomVertexBufferProperties* customVertexBufferProperties, ID2D1VertexBuffer** buffer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, VertexBufferProperties*, Guid*, CustomVertexBufferProperties*, ID2D1VertexBuffer**, int>)(lpVtbl[17]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), vertexBufferProperties, resourceId, customVertexBufferProperties, buffer);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.FindVertexBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult FindVertexBuffer(Guid* resourceId, ID2D1VertexBuffer** buffer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Guid*, ID2D1VertexBuffer**, int>)(lpVtbl[18]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), resourceId, buffer);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[19]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[20]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[21]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CheckFeatureSupport" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CheckFeatureSupport(Feature feature, void* featureSupportData, uint featureSupportDataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, Feature, void*, uint, int>)(lpVtbl[22]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), feature, featureSupportData, featureSupportDataSize);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, BufferPrecision, Bool32>)(lpVtbl[23]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext1::CreateLookupTable3D"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext1*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[24]))((ID2D1EffectContext1*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+}
+
+/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext2"]/*' />
+/// <unmanaged>ID2D1EffectContext2</unmanaged>
+[Guid("577ad2a0-9fc7-4dda-8b18-dab810140052")]
+[NativeTypeName("struct ID2D1EffectContext2 : ID2D1EffectContext1")]
+[NativeInheritance("ID2D1EffectContext1")]
+public unsafe partial struct ID2D1EffectContext2
+{
+	public static ref readonly Guid IID_ID2D1EffectContext2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xA0, 0xD2, 0x7A, 0x57,
+				0xC7, 0x9F,
+				0xDA, 0x4D,
+				0x8B,
+				0x18,
+				0xDA,
+				0xB8,
+				0x10,
+				0x14,
+				0x00,
+				0x52
+			};
+
+			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_ID2D1EffectContext2));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext1.CreateLookupTable3D" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateLookupTable3D(BufferPrecision precision, uint* extents, byte* data, uint dataCount, uint* strides, ID2D1LookupTable3D** lookupTable)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[3]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.GetDpi" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public void GetDpi(float* dpiX, float* dpiY)
+	{
+		((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, float*, float*, void>)(lpVtbl[4]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), dpiX, dpiY);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, ID2D1Effect**, int>)(lpVtbl[5]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), effectId, effect);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.GetMaximumSupportedFeatureLevel" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetMaximumSupportedFeatureLevel(Graphics.Direct3D.FeatureLevel* featureLevels, uint featureLevelsCount, Graphics.Direct3D.FeatureLevel* maximumSupportedFeatureLevel)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Graphics.Direct3D.FeatureLevel*, uint, Graphics.Direct3D.FeatureLevel*, int>)(lpVtbl[6]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), featureLevels, featureLevelsCount, maximumSupportedFeatureLevel);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateTransformNodeFromEffect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateTransformNodeFromEffect(ID2D1Effect* effect, ID2D1TransformNode** transformNode)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, ID2D1Effect*, ID2D1TransformNode**, int>)(lpVtbl[7]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), effect, transformNode);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateBlendTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateBlendTransform(uint numInputs, BlendDescription* blendDescription, ID2D1BlendTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, uint, BlendDescription*, ID2D1BlendTransform**, int>)(lpVtbl[8]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), numInputs, blendDescription, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateBorderTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateBorderTransform(ExtendMode extendModeX, ExtendMode extendModeY, ID2D1BorderTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, ExtendMode, ExtendMode, ID2D1BorderTransform**, int>)(lpVtbl[9]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), extendModeX, extendModeY, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateOffsetTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateOffsetTransform(System.Drawing.Point* offset, ID2D1OffsetTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, System.Drawing.Point*, ID2D1OffsetTransform**, int>)(lpVtbl[10]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), offset, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateBoundsAdjustmentTransform" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateBoundsAdjustmentTransform(RawRect* outputRectangle, ID2D1BoundsAdjustmentTransform** transform)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, RawRect*, ID2D1BoundsAdjustmentTransform**, int>)(lpVtbl[11]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), outputRectangle, transform);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.LoadPixelShader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult LoadPixelShader(Guid* shaderId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, byte*, uint, int>)(lpVtbl[12]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), shaderId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.LoadVertexShader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult LoadVertexShader(Guid* resourceId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, byte*, uint, int>)(lpVtbl[13]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), resourceId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.LoadComputeShader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult LoadComputeShader(Guid* resourceId, byte* shaderBuffer, uint shaderBufferCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, byte*, uint, int>)(lpVtbl[14]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), resourceId, shaderBuffer, shaderBufferCount);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.IsShaderLoaded" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public Bool32 IsShaderLoaded(Guid* shaderId)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, Bool32>)(lpVtbl[15]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), shaderId);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateResourceTexture" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateResourceTexture(Guid* resourceId, ResourceTextureProperties* resourceTextureProperties, byte* data, uint* strides, uint dataSize, ID2D1ResourceTexture** resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, ResourceTextureProperties*, byte*, uint*, uint, ID2D1ResourceTexture**, int>)(lpVtbl[16]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), resourceId, resourceTextureProperties, data, strides, dataSize, resourceTexture);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.FindResourceTexture" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult FindResourceTexture(Guid* resourceId, ID2D1ResourceTexture** resourceTexture)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, ID2D1ResourceTexture**, int>)(lpVtbl[17]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), resourceId, resourceTexture);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateVertexBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateVertexBuffer(VertexBufferProperties* vertexBufferProperties, Guid* resourceId, CustomVertexBufferProperties* customVertexBufferProperties, ID2D1VertexBuffer** buffer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, VertexBufferProperties*, Guid*, CustomVertexBufferProperties*, ID2D1VertexBuffer**, int>)(lpVtbl[18]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), vertexBufferProperties, resourceId, customVertexBufferProperties, buffer);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.FindVertexBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult FindVertexBuffer(Guid* resourceId, ID2D1VertexBuffer** buffer)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Guid*, ID2D1VertexBuffer**, int>)(lpVtbl[19]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), resourceId, buffer);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[20]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateColorContextFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[21]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), filename, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CreateColorContextFromWicColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[22]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.CheckFeatureSupport" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CheckFeatureSupport(Feature feature, void* featureSupportData, uint featureSupportDataSize)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Feature, void*, uint, int>)(lpVtbl[23]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), feature, featureSupportData, featureSupportDataSize);
+	}
+
+	/// <inheritdoc cref="ID2D1EffectContext.IsBufferPrecisionSupported" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, BufferPrecision, Bool32>)(lpVtbl[24]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), bufferPrecision);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext2::CreateColorContextFromDxgiColorSpace"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateColorContextFromDxgiColorSpace(Graphics.Dxgi.Common.ColorSpaceType colorSpace, ID2D1ColorContext1** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, Graphics.Dxgi.Common.ColorSpaceType, ID2D1ColorContext1**, int>)(lpVtbl[25]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), colorSpace, colorContext);
+	}
+
+	/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1EffectContext2::CreateColorContextFromSimpleColorProfile"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult CreateColorContextFromSimpleColorProfile(SimpleColorProfile* simpleProfile, ID2D1ColorContext1** colorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, SimpleColorProfile*, ID2D1ColorContext1**, int>)(lpVtbl[26]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), simpleProfile, colorContext);
+	}
+}
+
+#endregion Com Types
+
+#region Functions
+public static unsafe partial class Apis
+{
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern HResult D2D1CreateFactory(FactoryType factoryType, Guid* riid, FactoryOptions* pFactoryOptions, void** ppIFactory);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern void D2D1MakeRotateMatrix(float angle, System.Drawing.PointF* center, Matrix3x2* matrix);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern void D2D1MakeSkewMatrix(float angleX, float angleY, System.Drawing.PointF* center, Matrix3x2* matrix);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern Bool32 D2D1IsMatrixInvertible(Matrix3x2* matrix);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern Bool32 D2D1InvertMatrix(Matrix3x2* matrix);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern HResult D2D1CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, CreationProperties* creationProperties, ID2D1Device* d2dDevice);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern HResult D2D1CreateDeviceContext(Graphics.Dxgi.IDXGISurface* dxgiSurface, CreationProperties* creationProperties, ID2D1DeviceContext* d2dDeviceContext);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern Graphics.Direct2D.Common.ColorF D2D1ConvertColorSpace(ColorSpace sourceColorSpace, ColorSpace destinationColorSpace, Common.ColorF* color);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern void D2D1SinCos(float angle, float* s, float* c);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern float D2D1Tan(float angle);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern float D2D1Vec3Length(float x, float y, float z);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern float D2D1ComputeMaximumScaleFactor(Matrix3x2* matrix);
+
+	[DllImport("d2d1", ExactSpelling = true)]
+	public static extern void D2D1GetGradientMeshInteriorPointsFromCoonsPatch(System.Drawing.PointF* pPoint0, System.Drawing.PointF* pPoint1, System.Drawing.PointF* pPoint2, System.Drawing.PointF* pPoint3, System.Drawing.PointF* pPoint4, System.Drawing.PointF* pPoint5, System.Drawing.PointF* pPoint6, System.Drawing.PointF* pPoint7, System.Drawing.PointF* pPoint8, System.Drawing.PointF* pPoint9, System.Drawing.PointF* pPoint10, System.Drawing.PointF* pPoint11, System.Drawing.PointF* pTensorPoint11, System.Drawing.PointF* pTensorPoint12, System.Drawing.PointF* pTensorPoint21, System.Drawing.PointF* pTensorPoint22);
+
+}
+#endregion Functions
diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs
index 3240fae..0f815d6 100644
--- a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs
+++ b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs
@@ -10864,7 +10864,7 @@ public partial struct VideoProcessorStream
 	public unsafe ID3D11VideoProcessorInputView* ppPastSurfaces;
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="D3D11_VIDEO_PROCESSOR_STREAM::pInputSurface"]/*' />
-	public ID3D11VideoProcessorInputView pInputSurface;
+	public unsafe ID3D11VideoProcessorInputView* pInputSurface;
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="D3D11_VIDEO_PROCESSOR_STREAM::ppFutureSurfaces"]/*' />
 	public unsafe ID3D11VideoProcessorInputView* ppFutureSurfaces;
@@ -10873,7 +10873,7 @@ public partial struct VideoProcessorStream
 	public unsafe ID3D11VideoProcessorInputView* ppPastSurfacesRight;
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="D3D11_VIDEO_PROCESSOR_STREAM::pInputSurfaceRight"]/*' />
-	public ID3D11VideoProcessorInputView pInputSurfaceRight;
+	public unsafe ID3D11VideoProcessorInputView* pInputSurfaceRight;
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="D3D11_VIDEO_PROCESSOR_STREAM::ppFutureSurfacesRight"]/*' />
 	public unsafe ID3D11VideoProcessorInputView* ppFutureSurfacesRight;
@@ -11650,7 +11650,7 @@ public partial struct VideoDecoderBufferDescription1
 public partial struct VideoDecoderBeginFrameCryptoSession
 {
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION::pCryptoSession"]/*' />
-	public ID3D11CryptoSession pCryptoSession;
+	public unsafe ID3D11CryptoSession* pCryptoSession;
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION::BlobSize"]/*' />
 	public uint BlobSize;
diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs
index 70ab54e..f0cf6bd 100644
--- a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs
+++ b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs
@@ -7294,7 +7294,7 @@ public partial struct CachedPipelineState
 public partial struct GraphicsPipelineStateDescription
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_GRAPHICS_PIPELINE_STATE_DESC::pRootSignature"]/*' />
-	public ID3D12RootSignature pRootSignature;
+	public unsafe ID3D12RootSignature* pRootSignature;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_GRAPHICS_PIPELINE_STATE_DESC::VS"]/*' />
 	public ShaderBytecode VS;
@@ -7391,7 +7391,7 @@ public partial struct GraphicsPipelineStateDescription
 public partial struct ComputePipelineStateDescription
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_COMPUTE_PIPELINE_STATE_DESC::pRootSignature"]/*' />
-	public ID3D12RootSignature pRootSignature;
+	public unsafe ID3D12RootSignature* pRootSignature;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_COMPUTE_PIPELINE_STATE_DESC::CS"]/*' />
 	public ShaderBytecode CS;
@@ -8221,7 +8221,7 @@ public partial struct PackedMipInfo
 public partial struct ResourceTransitionBarrier
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_TRANSITION_BARRIER::pResource"]/*' />
-	public ID3D12Resource pResource;
+	public unsafe ID3D12Resource* pResource;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_TRANSITION_BARRIER::Subresource"]/*' />
 	public uint Subresource;
@@ -8238,10 +8238,10 @@ public partial struct ResourceTransitionBarrier
 public partial struct ResourceAliasingBarrier
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_ALIASING_BARRIER::pResourceBefore"]/*' />
-	public ID3D12Resource pResourceBefore;
+	public unsafe ID3D12Resource* pResourceBefore;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_ALIASING_BARRIER::pResourceAfter"]/*' />
-	public ID3D12Resource pResourceAfter;
+	public unsafe ID3D12Resource* pResourceAfter;
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_UAV_BARRIER"]/*' />
@@ -8249,7 +8249,7 @@ public partial struct ResourceAliasingBarrier
 public partial struct ResourceUavBarrier
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_UAV_BARRIER::pResource"]/*' />
-	public ID3D12Resource pResource;
+	public unsafe ID3D12Resource* pResource;
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RESOURCE_BARRIER"]/*' />
@@ -8361,7 +8361,7 @@ public partial struct PlacedSubresourceFootprint
 public partial struct TextureCopyLocation
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_TEXTURE_COPY_LOCATION::pResource"]/*' />
-	public ID3D12Resource pResource;
+	public unsafe ID3D12Resource* pResource;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_TEXTURE_COPY_LOCATION::Type"]/*' />
 	public TextureCopyType Type;
@@ -10433,7 +10433,7 @@ public partial struct StateObjectConfig
 public partial struct GlobalRootSignature
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_GLOBAL_ROOT_SIGNATURE::pGlobalRootSignature"]/*' />
-	public ID3D12RootSignature pGlobalRootSignature;
+	public unsafe ID3D12RootSignature* pGlobalRootSignature;
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_LOCAL_ROOT_SIGNATURE"]/*' />
@@ -10441,7 +10441,7 @@ public partial struct GlobalRootSignature
 public partial struct LocalRootSignature
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_LOCAL_ROOT_SIGNATURE::pLocalRootSignature"]/*' />
-	public ID3D12RootSignature pLocalRootSignature;
+	public unsafe ID3D12RootSignature* pLocalRootSignature;
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_NODE_MASK"]/*' />
@@ -10485,7 +10485,7 @@ public partial struct DxilLibraryDescription
 public partial struct ExistingCollectionDescription
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_EXISTING_COLLECTION_DESC::pExistingCollection"]/*' />
-	public ID3D12StateObject pExistingCollection;
+	public unsafe ID3D12StateObject* pExistingCollection;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_EXISTING_COLLECTION_DESC::NumExports"]/*' />
 	public uint NumExports;
@@ -10966,10 +10966,10 @@ public partial struct AutoBreadcrumbNode
 	public unsafe ushort* pCommandQueueDebugNameW;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_AUTO_BREADCRUMB_NODE::pCommandList"]/*' />
-	public ID3D12GraphicsCommandList pCommandList;
+	public unsafe ID3D12GraphicsCommandList* pCommandList;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_AUTO_BREADCRUMB_NODE::pCommandQueue"]/*' />
-	public ID3D12CommandQueue pCommandQueue;
+	public unsafe ID3D12CommandQueue* pCommandQueue;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_AUTO_BREADCRUMB_NODE::BreadcrumbCount"]/*' />
 	public uint BreadcrumbCount;
@@ -11012,10 +11012,10 @@ public partial struct AutoBreadcrumbNode1
 	public unsafe ushort* pCommandQueueDebugNameW;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_AUTO_BREADCRUMB_NODE1::pCommandList"]/*' />
-	public ID3D12GraphicsCommandList pCommandList;
+	public unsafe ID3D12GraphicsCommandList* pCommandList;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_AUTO_BREADCRUMB_NODE1::pCommandQueue"]/*' />
-	public ID3D12CommandQueue pCommandQueue;
+	public unsafe ID3D12CommandQueue* pCommandQueue;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_AUTO_BREADCRUMB_NODE1::BreadcrumbCount"]/*' />
 	public uint BreadcrumbCount;
@@ -11384,10 +11384,10 @@ public partial struct RenderPassEndingAccessResolveSubresourceParameters
 public partial struct RenderPassEndingAccessResolveParameters
 {
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS::pSrcResource"]/*' />
-	public ID3D12Resource pSrcResource;
+	public unsafe ID3D12Resource* pSrcResource;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS::pDstResource"]/*' />
-	public ID3D12Resource pDstResource;
+	public unsafe ID3D12Resource* pDstResource;
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS::SubresourceCount"]/*' />
 	public uint SubresourceCount;
diff --git a/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs b/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs
index e358e65..d378c46 100644
--- a/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs
+++ b/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs
@@ -2562,7 +2562,7 @@ public partial struct ShapingGlyphProperties
 public partial struct GlyphRun
 {
 	/// <include file='../DirectWrite.xml' path='doc/member[@name="DWRITE_GLYPH_RUN::fontFace"]/*' />
-	public IDWriteFontFace fontFace;
+	public unsafe IDWriteFontFace* fontFace;
 
 	/// <include file='../DirectWrite.xml' path='doc/member[@name="DWRITE_GLYPH_RUN::fontEmSize"]/*' />
 	public float fontEmSize;
diff --git a/src/Vortice.Win32/Generated/Graphics/Imaging.D2D.cs b/src/Vortice.Win32/Generated/Graphics/Imaging.D2D.cs
new file mode 100644
index 0000000..8b65176
--- /dev/null
+++ b/src/Vortice.Win32/Generated/Graphics/Imaging.D2D.cs
@@ -0,0 +1,358 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+using System;
+using System.Numerics;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+
+#if !NET6_0_OR_GREATER
+using MemoryMarshal = Win32.MemoryMarshal;
+#endif
+
+namespace Win32.Graphics.Imaging.D2D;
+
+public static partial class Apis
+{
+}
+
+#region COM Types
+/// <include file='../Imaging.xml' path='doc/member[@name="IWICImageEncoder"]/*' />
+/// <unmanaged>IWICImageEncoder</unmanaged>
+[Guid("04c75bf8-3ce1-473b-acc5-3cc4f5e94999")]
+[NativeTypeName("struct IWICImageEncoder : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IWICImageEncoder
+{
+	public static ref readonly Guid IID_IWICImageEncoder
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0xF8, 0x5B, 0xC7, 0x04,
+				0xE1, 0x3C,
+				0x3B, 0x47,
+				0xAC,
+				0xC5,
+				0x3C,
+				0xC4,
+				0xF5,
+				0xE9,
+				0x49,
+				0x99
+			};
+
+			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_IWICImageEncoder));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <include file='../Imaging.xml' path='doc/member[@name="IWICImageEncoder::WriteFrame"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult WriteFrame(Graphics.Direct2D.ID2D1Image* pImage, Graphics.Imaging.IWICBitmapFrameEncode* pFrameEncode, Graphics.Imaging.WICImageParameters* pImageParameters)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImageEncoder*, Graphics.Direct2D.ID2D1Image*, Graphics.Imaging.IWICBitmapFrameEncode*, Graphics.Imaging.WICImageParameters*, int>)(lpVtbl[3]))((IWICImageEncoder*)Unsafe.AsPointer(ref this), pImage, pFrameEncode, pImageParameters);
+	}
+
+	/// <include file='../Imaging.xml' path='doc/member[@name="IWICImageEncoder::WriteFrameThumbnail"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult WriteFrameThumbnail(Graphics.Direct2D.ID2D1Image* pImage, Graphics.Imaging.IWICBitmapFrameEncode* pFrameEncode, Graphics.Imaging.WICImageParameters* pImageParameters)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImageEncoder*, Graphics.Direct2D.ID2D1Image*, Graphics.Imaging.IWICBitmapFrameEncode*, Graphics.Imaging.WICImageParameters*, int>)(lpVtbl[4]))((IWICImageEncoder*)Unsafe.AsPointer(ref this), pImage, pFrameEncode, pImageParameters);
+	}
+
+	/// <include file='../Imaging.xml' path='doc/member[@name="IWICImageEncoder::WriteThumbnail"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult WriteThumbnail(Graphics.Direct2D.ID2D1Image* pImage, Graphics.Imaging.IWICBitmapEncoder* pEncoder, Graphics.Imaging.WICImageParameters* pImageParameters)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImageEncoder*, Graphics.Direct2D.ID2D1Image*, Graphics.Imaging.IWICBitmapEncoder*, Graphics.Imaging.WICImageParameters*, int>)(lpVtbl[5]))((IWICImageEncoder*)Unsafe.AsPointer(ref this), pImage, pEncoder, pImageParameters);
+	}
+}
+
+/// <include file='../Imaging.xml' path='doc/member[@name="IWICImagingFactory2"]/*' />
+/// <unmanaged>IWICImagingFactory2</unmanaged>
+[Guid("7b816b45-1996-4476-b132-de9e247c8af0")]
+[NativeTypeName("struct IWICImagingFactory2 : IWICImagingFactory")]
+[NativeInheritance("IWICImagingFactory")]
+public unsafe partial struct IWICImagingFactory2
+{
+	public static ref readonly Guid IID_IWICImagingFactory2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> data = new byte[] {
+				0x45, 0x6B, 0x81, 0x7B,
+				0x96, 0x19,
+				0x76, 0x44,
+				0xB1,
+				0x32,
+				0xDE,
+				0x9E,
+				0x24,
+				0x7C,
+				0x8A,
+				0xF0
+			};
+
+			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_IWICImagingFactory2));
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateDecoderFromFilename" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult CreateDecoderFromFilename(ushort* wzFilename, Guid* pguidVendor, uint dwDesiredAccess, Graphics.Imaging.WICDecodeOptions metadataOptions, Graphics.Imaging.IWICBitmapDecoder** ppIDecoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, ushort*, Guid*, uint, Graphics.Imaging.WICDecodeOptions, Graphics.Imaging.IWICBitmapDecoder**, int>)(lpVtbl[0]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateDecoderFromStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	public HResult CreateDecoderFromStream(Com.IStream* pIStream, Guid* pguidVendor, Graphics.Imaging.WICDecodeOptions metadataOptions, Graphics.Imaging.IWICBitmapDecoder** ppIDecoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Com.IStream*, Guid*, Graphics.Imaging.WICDecodeOptions, Graphics.Imaging.IWICBitmapDecoder**, int>)(lpVtbl[1]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pIStream, pguidVendor, metadataOptions, ppIDecoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateDecoderFromFileHandle" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	public HResult CreateDecoderFromFileHandle(nuint hFile, Guid* pguidVendor, Graphics.Imaging.WICDecodeOptions metadataOptions, Graphics.Imaging.IWICBitmapDecoder** ppIDecoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, nuint, Guid*, Graphics.Imaging.WICDecodeOptions, Graphics.Imaging.IWICBitmapDecoder**, int>)(lpVtbl[2]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), hFile, pguidVendor, metadataOptions, ppIDecoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateComponentInfo" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult CreateComponentInfo(Guid* clsidComponent, Graphics.Imaging.IWICComponentInfo** ppIInfo)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Guid*, Graphics.Imaging.IWICComponentInfo**, int>)(lpVtbl[3]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), clsidComponent, ppIInfo);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateDecoder" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult CreateDecoder(Guid* guidContainerFormat, Guid* pguidVendor, Graphics.Imaging.IWICBitmapDecoder** ppIDecoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Guid*, Guid*, Graphics.Imaging.IWICBitmapDecoder**, int>)(lpVtbl[4]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, ppIDecoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateEncoder" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult CreateEncoder(Guid* guidContainerFormat, Guid* pguidVendor, Graphics.Imaging.IWICBitmapEncoder** ppIEncoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Guid*, Guid*, Graphics.Imaging.IWICBitmapEncoder**, int>)(lpVtbl[5]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, ppIEncoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreatePalette" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult CreatePalette(Graphics.Imaging.IWICPalette** ppIPalette)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICPalette**, int>)(lpVtbl[6]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIPalette);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateFormatConverter" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult CreateFormatConverter(Graphics.Imaging.IWICFormatConverter** ppIFormatConverter)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICFormatConverter**, int>)(lpVtbl[7]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIFormatConverter);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapScaler" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult CreateBitmapScaler(Graphics.Imaging.IWICBitmapScaler** ppIBitmapScaler)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapScaler**, int>)(lpVtbl[8]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIBitmapScaler);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapClipper" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateBitmapClipper(Graphics.Imaging.IWICBitmapClipper** ppIBitmapClipper)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapClipper**, int>)(lpVtbl[9]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIBitmapClipper);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapFlipRotator" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult CreateBitmapFlipRotator(Graphics.Imaging.IWICBitmapFlipRotator** ppIBitmapFlipRotator)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapFlipRotator**, int>)(lpVtbl[10]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIBitmapFlipRotator);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateStream" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult CreateStream(Graphics.Imaging.IWICStream** ppIWICStream)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICStream**, int>)(lpVtbl[11]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIWICStream);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateColorContext" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(12)]
+	public HResult CreateColorContext(Graphics.Imaging.IWICColorContext** ppIWICColorContext)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICColorContext**, int>)(lpVtbl[12]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIWICColorContext);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateColorTransformer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult CreateColorTransformer(Graphics.Imaging.IWICColorTransform** ppIWICColorTransform)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICColorTransform**, int>)(lpVtbl[13]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), ppIWICColorTransform);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmap" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, Graphics.Imaging.WICBitmapCreateCacheOption option, Graphics.Imaging.IWICBitmap** ppIBitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, uint, uint, Guid*, Graphics.Imaging.WICBitmapCreateCacheOption, Graphics.Imaging.IWICBitmap**, int>)(lpVtbl[14]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), uiWidth, uiHeight, pixelFormat, option, ppIBitmap);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapFromSource" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult CreateBitmapFromSource(Graphics.Imaging.IWICBitmapSource* pIBitmapSource, Graphics.Imaging.WICBitmapCreateCacheOption option, Graphics.Imaging.IWICBitmap** ppIBitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapSource*, Graphics.Imaging.WICBitmapCreateCacheOption, Graphics.Imaging.IWICBitmap**, int>)(lpVtbl[15]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pIBitmapSource, option, ppIBitmap);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapFromSourceRect" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult CreateBitmapFromSourceRect(Graphics.Imaging.IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, Graphics.Imaging.IWICBitmap** ppIBitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapSource*, uint, uint, uint, uint, Graphics.Imaging.IWICBitmap**, int>)(lpVtbl[16]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pIBitmapSource, x, y, width, height, ppIBitmap);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapFromMemory" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, Graphics.Imaging.IWICBitmap** ppIBitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, uint, uint, Guid*, uint, uint, byte*, Graphics.Imaging.IWICBitmap**, int>)(lpVtbl[17]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapFromHBITMAP" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult CreateBitmapFromHBITMAP(IntPtr hBitmap, IntPtr hPalette, Graphics.Imaging.WICBitmapAlphaChannelOption options, Graphics.Imaging.IWICBitmap** ppIBitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, IntPtr, IntPtr, Graphics.Imaging.WICBitmapAlphaChannelOption, Graphics.Imaging.IWICBitmap**, int>)(lpVtbl[18]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), hBitmap, hPalette, options, ppIBitmap);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateBitmapFromHICON" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult CreateBitmapFromHICON(IntPtr hIcon, Graphics.Imaging.IWICBitmap** ppIBitmap)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, IntPtr, Graphics.Imaging.IWICBitmap**, int>)(lpVtbl[19]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), hIcon, ppIBitmap);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateComponentEnumerator" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public HResult CreateComponentEnumerator(uint componentTypes, uint options, Com.IEnumUnknown** ppIEnumUnknown)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, uint, uint, Com.IEnumUnknown**, int>)(lpVtbl[20]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), componentTypes, options, ppIEnumUnknown);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateFastMetadataEncoderFromDecoder" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult CreateFastMetadataEncoderFromDecoder(Graphics.Imaging.IWICBitmapDecoder* pIDecoder, Graphics.Imaging.IWICFastMetadataEncoder** ppIFastEncoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapDecoder*, Graphics.Imaging.IWICFastMetadataEncoder**, int>)(lpVtbl[21]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pIDecoder, ppIFastEncoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateFastMetadataEncoderFromFrameDecode" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult CreateFastMetadataEncoderFromFrameDecode(Graphics.Imaging.IWICBitmapFrameDecode* pIFrameDecoder, Graphics.Imaging.IWICFastMetadataEncoder** ppIFastEncoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICBitmapFrameDecode*, Graphics.Imaging.IWICFastMetadataEncoder**, int>)(lpVtbl[22]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pIFrameDecoder, ppIFastEncoder);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateQueryWriter" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult CreateQueryWriter(Guid* guidMetadataFormat, Guid* pguidVendor, Graphics.Imaging.IWICMetadataQueryWriter** ppIQueryWriter)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Guid*, Guid*, Graphics.Imaging.IWICMetadataQueryWriter**, int>)(lpVtbl[23]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), guidMetadataFormat, pguidVendor, ppIQueryWriter);
+	}
+
+	/// <inheritdoc cref="IWICImagingFactory.CreateQueryWriterFromReader" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CreateQueryWriterFromReader(Graphics.Imaging.IWICMetadataQueryReader* pIQueryReader, Guid* pguidVendor, Graphics.Imaging.IWICMetadataQueryWriter** ppIQueryWriter)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Imaging.IWICMetadataQueryReader*, Guid*, Graphics.Imaging.IWICMetadataQueryWriter**, int>)(lpVtbl[24]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pIQueryReader, pguidVendor, ppIQueryWriter);
+	}
+
+	/// <include file='../Imaging.xml' path='doc/member[@name="IWICImagingFactory2::CreateImageEncoder"]/*' />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult CreateImageEncoder(Graphics.Direct2D.ID2D1Device* pD2DDevice, IWICImageEncoder** ppWICImageEncoder)
+	{
+		return ((delegate* unmanaged[Stdcall]<IWICImagingFactory2*, Graphics.Direct2D.ID2D1Device*, IWICImageEncoder**, int>)(lpVtbl[25]))((IWICImagingFactory2*)Unsafe.AsPointer(ref this), pD2DDevice, ppWICImageEncoder);
+	}
+}
+
+#endregion Com Types
+
diff --git a/src/Vortice.Win32/Graphics/Imaging/Apis.cs b/src/Vortice.Win32/Graphics/Imaging/Apis.cs
index e19abc8..7fa8823 100644
--- a/src/Vortice.Win32/Graphics/Imaging/Apis.cs
+++ b/src/Vortice.Win32/Graphics/Imaging/Apis.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
 
 using System.Runtime.CompilerServices;
+using Win32.Graphics.Imaging.D2D;
 using static Win32.Apis;
 
 namespace Win32.Graphics.Imaging;
@@ -17,4 +18,14 @@ public static unsafe partial class Apis
             __uuidof<IWICImagingFactory>(),
             (void**)factory);
     }
+
+    public static HResult CreateWICImagingFactory(IWICImagingFactory2** factory)
+    {
+        return CoCreateInstance(
+            (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in CLSID_WICImagingFactory2)),
+            null,
+            CLSCTX_INPROC_SERVER,
+            __uuidof<IWICImagingFactory2>(),
+            (void**)factory);
+    }
 }
diff --git a/src/Vortice.Win32/Vortice.Win32.csproj b/src/Vortice.Win32/Vortice.Win32.csproj
index f0d0cdb..ee07c80 100644
--- a/src/Vortice.Win32/Vortice.Win32.csproj
+++ b/src/Vortice.Win32/Vortice.Win32.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net6.0;</TargetFrameworks>
     <Description>Windows API low level bindings.</Description>
-    <VersionPrefix>1.4.1</VersionPrefix>
+    <VersionPrefix>1.5.0</VersionPrefix>
     <VersionSuffix Condition="'$(VersionSuffix)' == ''"></VersionSuffix>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/src/samples/01-ClearScreen/Program.cs b/src/samples/01-ClearScreen/Program.cs
index 9500194..a329f82 100644
--- a/src/samples/01-ClearScreen/Program.cs
+++ b/src/samples/01-ClearScreen/Program.cs
@@ -15,9 +15,15 @@ using static Win32.Graphics.Direct3D11.Apis;
 using static Win32.Graphics.Dxgi.Apis;
 using static Win32.Graphics.Imaging.Apis;
 using static Win32.Graphics.DirectWrite.Apis;
+using static Win32.Graphics.Direct2D.Apis;
 using InfoQueueFilter = Win32.Graphics.Direct3D11.InfoQueueFilter;
 using MessageId = Win32.Graphics.Direct3D11.MessageId;
+using Win32.Graphics.Direct2D;
 using Win32.Graphics.DirectWrite;
+using FactoryType = Win32.Graphics.Direct2D.FactoryType;
+using DWriteFactoryType = Win32.Graphics.DirectWrite.FactoryType;
+using FeatureLevel = Win32.Graphics.Direct3D.FeatureLevel;
+using Win32.Graphics.Imaging.D2D;
 
 namespace ClearScreen;
 
@@ -54,11 +60,11 @@ public static unsafe class Program
         string assetsPath = Path.Combine(AppContext.BaseDirectory, "Assets", "Textures");
         string textureFile = Path.Combine(assetsPath, "10points.png");
 
-        using ComPtr<IWICImagingFactory> wicImagingFactory = default;
-
+        using ComPtr<IWICImagingFactory2> wicImagingFactory = default;
         CreateWICImagingFactory(wicImagingFactory.GetAddressOf()).ThrowIfFailed();
 
-        using ComPtr<IWICBitmapDecoder> decoder = wicImagingFactory.Get()->CreateDecoderFromFilename(textureFile);
+        using ComPtr<IWICBitmapDecoder> decoder =
+            ((IWICImagingFactory*)wicImagingFactory.Get())->CreateDecoderFromFilename(textureFile);
 
         using ComPtr<IWICBitmapFrameDecode> wicBitmapFrameDecode = default;
 
@@ -76,8 +82,15 @@ public static unsafe class Program
 
     private static void TestD2D1AndDWrite()
     {
+        using ComPtr<ID2D1Factory2> d2d1Factory2 = default;
+
+        D2D1CreateFactory(FactoryType.MultiThreaded,
+            __uuidof<ID2D1Factory2>(),
+            default,
+            d2d1Factory2.GetVoidAddressOf()).ThrowIfFailed();
+
         using ComPtr<IDWriteFactory> dwriteFactory = default;
-        DWriteCreateFactory(FactoryType.Shared, __uuidof<IDWriteFactory>(), dwriteFactory.GetIUnknownAddressOf()).ThrowIfFailed();
+        DWriteCreateFactory(DWriteFactoryType.Shared, __uuidof<IDWriteFactory>(), dwriteFactory.GetIUnknownAddressOf()).ThrowIfFailed();
 
         using ComPtr<IDWriteTextFormat> textFormat =
             dwriteFactory.Get()->CreateTextFormat(