mirror/Vortice.Win32
1
0
Fork 0
mirror of https://github.com/amerkoleci/Vortice.Win32.git synced 2026-01-14 16:16:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Generator: Separate com types and FIX vtable issues

Browse Source
This commit is contained in:
Amer Koleci
2022-09-20 11:02:04 +02:00
parent a3c160a929
commit e757fc08ae
512 changed files with 107122 additions and 96605 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/Generator/ApiData.cs
View File

@@ -86,6 +86,11 @@ public class ApiType
public List<object> ReturnAttrs { get; set; }
public IList<ApiParameter> Params { get; set; } = new List<ApiParameter>();
public string DllImport { get; set; }
public override string ToString()
{
return $"{Kind}: {Name}";
}
}
public sealed class ApiData

11
src/Generator/CodeWriter.cs
View File

@@ -7,19 +7,22 @@ namespace Generator;
public sealed class CodeWriter : IDisposable
{
private readonly string _fileName;
private bool _shouldIndent = true;
private readonly string[] _indentStrings;
private string _indentString = "";
private readonly StringBuilder _builder = new();
public int IndentLevel { get; private set; }
public string FileName { get; }
public string Api { get; }
public string DocFileName { get; }
public string Directory => Path.GetDirectoryName(FileName)!;
public CodeWriter(string fileName, string api, string docFileName, string ns, params string[] usingNamespaces)
{
_fileName = fileName;
FileName = fileName;
Api = api;
DocFileName = docFileName;
@@ -62,10 +65,10 @@ public sealed class CodeWriter : IDisposable
public void Dispose()
{
if (string.IsNullOrEmpty(_fileName) == false)
if (string.IsNullOrEmpty(FileName) == false)
{
string content = _builder.ToString();
File.WriteAllText(_fileName, content);
File.WriteAllText(FileName, content);
}
}

429
src/Generator/Program.cs
View File

@@ -2,6 +2,7 @@
// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using Newtonsoft.Json;
@@ -868,7 +869,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<ApiType, string>>> s_visitedComTypes = new();
private static readonly Dictionary<string, Dictionary<string, List<ApiType>>> s_visitedComTypes = new();
private static bool s_generateUnmanagedDocs = true;
@@ -943,6 +944,17 @@ public static class Program
fileName += ".cs";
if (docFile != "json")
{
string subdirectory = Path.Combine(outputFolder, docFile);
if (Directory.Exists(subdirectory) == false)
Directory.CreateDirectory(subdirectory);
}
else
{
docFile = string.Empty;
}
using var writer = new CodeWriter(
Path.Combine(outputFolder, fileName),
ns,
@@ -1176,8 +1188,16 @@ public static class Program
// Generate methods
// TODO: FIX broken VTable ID3D12Heap, ID2D1Factory2
List<KeyValuePair<ApiType, string>> methodsToGenerate = new();
if (comType.Name == "ID3D12Pageable")
{
}
Dictionary<string, List<ApiType>> methodsToGenerate = new();
// We must generate from lower to upper
ApiType iterateType = comType;
List<ApiType> typesToGenerate = new();
while (iterateType.Interface != null
&& iterateType.Interface.Name != "IUnknown"
&& iterateType.Interface.Name != "IStream"
@@ -1188,14 +1208,7 @@ public static class Program
if (iterateType != null)
{
foreach (ApiType method in iterateType.Methods)
{
// Until we add Storage.Xps.Printing.IPrintDocumentPackageTarget
if (method.Name == "CreatePrintControl")
continue;
methodsToGenerate.Add(new(method, iterateType.Name));
}
typesToGenerate.Add(iterateType);
}
else
{
@@ -1203,23 +1216,59 @@ public static class Program
foreach (var knownMethod in knownMethods)
{
methodsToGenerate.Add(knownMethod);
methodsToGenerate.Add(knownMethod.Key, knownMethod.Value);
}
break;
}
}
if (typesToGenerate.Count > 1)
{
typesToGenerate.Reverse();
}
foreach (ApiType type in typesToGenerate)
{
foreach (ApiType method in type.Methods)
{
// Until we add Storage.Xps.Printing.IPrintDocumentPackageTarget
if (method.Name == "CreatePrintControl")
continue;
if (methodsToGenerate.TryGetValue(type.Name, out List<ApiType>? functions) == false)
{
functions = new List<ApiType>();
methodsToGenerate.Add(type.Name, functions);
}
functions.Add(method);
}
}
foreach (ApiType method in comType.Methods)
{
// Until we add Storage.Xps.Printing.IPrintDocumentPackageTarget
if (method.Name == "CreatePrintControl")
continue;
methodsToGenerate.Add(new(method, comType.Name));
if (methodsToGenerate.TryGetValue(comType.Name, out List<ApiType>? functions) == false)
{
functions = new List<ApiType>();
methodsToGenerate.Add(comType.Name, functions);
}
functions.Add(method);
}
GenerateComType(api, writer, comType, methodsToGenerate);
string subdirectory = Path.Combine(writer.Directory, writer.DocFileName);
string fileName = $"{comType.Name}.cs";
using var comTypeWriter = new CodeWriter(
Path.Combine(subdirectory, fileName),
writer.Api,
"../" + writer.DocFileName,
$"Win32.{writer.Api}");
GenerateComType(api, comTypeWriter, comType, methodsToGenerate);
}
if (regionWritten)
@@ -1773,7 +1822,7 @@ public static class Program
ApiData api,
CodeWriter writer,
ApiType comType,
List<KeyValuePair<ApiType, string>> methodsToGenerate)
Dictionary<string, List<ApiType>> methodsToGenerate)
{
string csTypeName = comType.Name;
@@ -1860,227 +1909,229 @@ public static class Program
}
bool needNewLine = false;
foreach (KeyValuePair<ApiType, string> methodPair in methodsToGenerate)
foreach (KeyValuePair<string, List<ApiType>> methodPair in methodsToGenerate)
{
if (needNewLine)
string docName = methodPair.Key;
foreach (ApiType method in methodPair.Value)
{
writer.WriteLine();
}
ApiType method = methodPair.Key;
string docName = methodPair.Value;
// TODO: Handle inherit
string returnType = GetTypeName(method.ReturnType);
StringBuilder argumentBuilder = new();
StringBuilder argumentsTypesBuilder = new();
StringBuilder argumentsNameBuilder = new();
int parameterIndex = 0;
bool allOptional = false;
if (method.Name == "EndDraw")
{
allOptional =
method.Params.All(item => item.Attrs.Any(attr => attr is string str && str == "Optional"));
}
bool useReturnAsParameter = false;
if (returnType != "void" &&
method.ReturnType.TargetKind != "Com" &&
method.ReturnType.Kind == "ApiRef" &&
!IsPrimitive(method.ReturnType) &&
!IsEnum(method.ReturnType))
{
useReturnAsParameter = true;
}
// Return type
returnType = NormalizeTypeName(writer.Api, returnType);
string returnMarshalType = returnType;
if (returnMarshalType.ToLower() == "hresult")
{
returnMarshalType = "int";
}
if (useReturnAsParameter)
{
argumentsTypesBuilder.Append(returnMarshalType);
argumentsTypesBuilder.Append('*');
if (method.Params.Count > 0)
if (needNewLine)
{
argumentsTypesBuilder.Append(", ");
writer.WriteLine();
}
}
foreach (ApiParameter parameter in method.Params)
{
bool asPointer = false;
string parameterType = string.Empty;
// TODO: Handle inherit
string returnType = GetTypeName(method.ReturnType);
if (parameter.Type.Kind == "ApiRef")
StringBuilder argumentBuilder = new();
StringBuilder argumentsTypesBuilder = new();
StringBuilder argumentsNameBuilder = new();
int parameterIndex = 0;
bool allOptional = false;
if (method.Name == "EndDraw")
{
if (parameter.Type.TargetKind == "FunctionPointer")
allOptional =
method.Params.All(item => item.Attrs.Any(attr => attr is string str && str == "Optional"));
}
bool useReturnAsParameter = false;
if (returnType != "void" &&
method.ReturnType.TargetKind != "Com" &&
method.ReturnType.Kind == "ApiRef" &&
!IsPrimitive(method.ReturnType) &&
!IsEnum(method.ReturnType))
{
useReturnAsParameter = true;
}
// Return type
returnType = NormalizeTypeName(writer.Api, returnType);
string returnMarshalType = returnType;
if (returnMarshalType.ToLower() == "hresult")
{
returnMarshalType = "int";
}
if (useReturnAsParameter)
{
argumentsTypesBuilder.Append(returnMarshalType);
argumentsTypesBuilder.Append('*');
if (method.Params.Count > 0)
{
ApiType functionType = api.Types.First(item => item.Name == parameter.Type.Name && item.Kind == "FunctionPointer");
parameterType = "delegate* unmanaged[Stdcall]<void*, void>";
argumentsTypesBuilder.Append(", ");
}
else
}
foreach (ApiParameter parameter in method.Params)
{
bool asPointer = false;
string parameterType = string.Empty;
if (parameter.Type.Kind == "ApiRef")
{
string fullTypeName = $"{parameter.Type.Api}.{parameter.Type.Name}";
if (!IsPrimitive(parameter.Type) && !IsEnum(fullTypeName))
if (parameter.Type.TargetKind == "FunctionPointer")
{
asPointer = true;
ApiType functionType = api.Types.First(item => item.Name == parameter.Type.Name && item.Kind == "FunctionPointer");
parameterType = "delegate* unmanaged[Stdcall]<void*, void>";
}
else
{
string fullTypeName = $"{parameter.Type.Api}.{parameter.Type.Name}";
if (!IsPrimitive(parameter.Type) && !IsEnum(fullTypeName))
{
asPointer = true;
}
}
}
}
if (string.IsNullOrEmpty(parameterType))
{
string parameterNameLookup = $"{comType.Name}::{method.Name}::{parameter.Name}";
if (s_mapFunctionParameters.TryGetValue(parameterNameLookup, out string? remapType))
if (string.IsNullOrEmpty(parameterType))
{
parameterType = GetTypeName($"{writer.Api}.{remapType}");
if (parameter.Attrs.Any(item => item is string str && str == "Out"))
string parameterNameLookup = $"{comType.Name}::{method.Name}::{parameter.Name}";
if (s_mapFunctionParameters.TryGetValue(parameterNameLookup, out string? remapType))
{
parameterType += "*";
parameterType = GetTypeName($"{writer.Api}.{remapType}");
if (parameter.Attrs.Any(item => item is string str && str == "Out"))
{
parameterType += "*";
}
}
else
{
parameterType = GetTypeName(parameter.Type, asPointer);
}
}
else
{
parameterType = GetTypeName(parameter.Type, asPointer);
}
}
parameterType = NormalizeTypeName(writer.Api, parameterType);
string parameterName = parameter.Name;
parameterType = NormalizeTypeName(writer.Api, parameterType);
string parameterName = parameter.Name;
bool isOptional = parameter.Attrs.Any(item => item is string str && str == "Optional");
if (parameter.Attrs.Any(item => item is string str && str == "ComOutPtr"))
{
if (!IsPrimitive(parameter.Type))
{
parameterType += "*";
}
}
else if (parameterType.EndsWith("**") == false &&
parameter.Attrs.Any(item => item is string str && (str == "RetVal" || str == "Out")))
{
if (parameter.Type.Child == null)
{
//if (!IsPrimitive(parameter.Type))
//{
// parameterType += "*";
//}
}
else if (parameter.Type.Child.Kind != "ApiRef")
bool isOptional = parameter.Attrs.Any(item => item is string str && str == "Optional");
if (parameter.Attrs.Any(item => item is string str && str == "ComOutPtr"))
{
if (!IsPrimitive(parameter.Type))
{
parameterType += "*";
}
}
else
else if (parameterType.EndsWith("**") == false &&
parameter.Attrs.Any(item => item is string str && (str == "RetVal" || str == "Out")))
{
string apiName = GetApiName(parameter.Type.Child);
string fullTypeName = $"{apiName}.{parameter.Type.Child.Name}";
if (!IsPrimitive(parameter.Type) && !IsStruct(fullTypeName) && !IsEnum(fullTypeName))
if (parameter.Type.Child == null)
{
parameterType += "*";
//if (!IsPrimitive(parameter.Type))
//{
// parameterType += "*";
//}
}
else if (parameter.Type.Child.Kind != "ApiRef")
{
if (!IsPrimitive(parameter.Type))
{
parameterType += "*";
}
}
else
{
string apiName = GetApiName(parameter.Type.Child);
string fullTypeName = $"{apiName}.{parameter.Type.Child.Name}";
if (!IsPrimitive(parameter.Type) && !IsStruct(fullTypeName) && !IsEnum(fullTypeName))
{
parameterType += "*";
}
}
}
parameterName = CleanupName(parameterName);
parameterType = NormalizeTypeName(writer.Api, parameterType);
argumentBuilder.Append(parameterType).Append(' ').Append(parameterName);
if (allOptional == true && isOptional == true)
{
argumentBuilder.Append(" = null");
}
argumentsTypesBuilder.Append(parameterType);
argumentsNameBuilder.Append(parameterName);
if (parameterIndex < method.Params.Count - 1)
{
argumentBuilder.Append(", ");
argumentsTypesBuilder.Append(", ");
argumentsNameBuilder.Append(", ");
}
parameterIndex++;
}
parameterName = CleanupName(parameterName);
parameterType = NormalizeTypeName(writer.Api, parameterType);
argumentBuilder.Append(parameterType).Append(' ').Append(parameterName);
if (allOptional == true && isOptional == true)
if (method.Params.Count > 0 || useReturnAsParameter)
{
argumentBuilder.Append(" = null");
}
argumentsTypesBuilder.Append(parameterType);
argumentsNameBuilder.Append(parameterName);
if (parameterIndex < method.Params.Count - 1)
{
argumentBuilder.Append(", ");
argumentsTypesBuilder.Append(", ");
argumentsNameBuilder.Append(", ");
}
parameterIndex++;
}
if (method.Params.Count > 0 || useReturnAsParameter)
{
argumentsTypesBuilder.Append(", ");
}
argumentsTypesBuilder.Append(returnMarshalType);
if (useReturnAsParameter)
{
argumentsTypesBuilder.Append('*');
}
string argumentsString = argumentBuilder.ToString();
string argumentTypesString = argumentsTypesBuilder.ToString();
string argumentNamesString = argumentsNameBuilder.ToString();
if (method.Params.Count > 0)
{
argumentNamesString = ", " + argumentNamesString;
}
if (comType.Name == docName)
{
writer.WriteLine($"/// <include file='../{writer.DocFileName}.xml' path='doc/member[@name=\"{comType.Name}::{method.Name}\"]/*' />");
}
else
{
writer.WriteLine($"/// <inheritdoc cref=\"{docName}.{method.Name}\" />");
}
writer.WriteLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]");
writer.WriteLine($"[VtblIndex({vtblIndex})]");
string methodSuffix = string.Empty;
if (method.Name == "GetType")
{
if (string.IsNullOrEmpty(argumentsString))
argumentsTypesBuilder.Append(returnMarshalType);
if (useReturnAsParameter)
{
methodSuffix = "new ";
argumentsTypesBuilder.Append('*');
}
}
using (writer.PushBlock($"public {methodSuffix}{returnType} {method.Name}({argumentsString})"))
{
if (returnType != "void")
string argumentsString = argumentBuilder.ToString();
string argumentTypesString = argumentsTypesBuilder.ToString();
string argumentNamesString = argumentsNameBuilder.ToString();
if (method.Params.Count > 0)
{
if (useReturnAsParameter)
argumentNamesString = ", " + argumentNamesString;
}
if (comType.Name == docName)
{
writer.WriteLine($"/// <include file='../{writer.DocFileName}.xml' path='doc/member[@name=\"{comType.Name}::{method.Name}\"]/*' />");
}
else
{
writer.WriteLine($"/// <inheritdoc cref=\"{docName}.{method.Name}\" />");
}
writer.WriteLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]");
writer.WriteLine($"[VtblIndex({vtblIndex})]");
string methodSuffix = string.Empty;
if (method.Name == "GetType")
{
if (string.IsNullOrEmpty(argumentsString))
{
writer.WriteLine($"{returnType} result;");
writer.Write("return ");
writer.WriteLine($"*((delegate* unmanaged[Stdcall]<{comType.Name}*, {argumentTypesString}>)(lpVtbl[{vtblIndex}]))(({comType.Name}*)Unsafe.AsPointer(ref this), &result{argumentNamesString});");
}
else
{
writer.Write("return ");
methodSuffix = "new ";
}
}
if (!useReturnAsParameter)
using (writer.PushBlock($"public {methodSuffix}{returnType} {method.Name}({argumentsString})"))
{
writer.WriteLine($"((delegate* unmanaged[Stdcall]<{comType.Name}*, {argumentTypesString}>)(lpVtbl[{vtblIndex}]))(({comType.Name}*)Unsafe.AsPointer(ref this){argumentNamesString});");
}
}
if (returnType != "void")
{
if (useReturnAsParameter)
{
writer.WriteLine($"{returnType} result;");
writer.Write("return ");
writer.WriteLine($"*((delegate* unmanaged[Stdcall]<{comType.Name}*, {argumentTypesString}>)(lpVtbl[{vtblIndex}]))(({comType.Name}*)Unsafe.AsPointer(ref this), &result{argumentNamesString});");
}
else
{
writer.Write("return ");
}
}
needNewLine = true;
vtblIndex++;
if (!useReturnAsParameter)
{
writer.WriteLine($"((delegate* unmanaged[Stdcall]<{comType.Name}*, {argumentTypesString}>)(lpVtbl[{vtblIndex}]))(({comType.Name}*)Unsafe.AsPointer(ref this){argumentNamesString});");
}
}
needNewLine = true;
vtblIndex++;
}
}
}

118
src/Vortice.Win32/Generated/Graphics/Direct2D.Common.cs
View File

@@ -341,123 +341,5 @@ public partial struct BezierSegment
#endregion Structs
#region COM Types
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink"]/*' />
/// <unmanaged>ID2D1SimplifiedGeometrySink</unmanaged>
[Guid("2cd9069e-12e2-11dc-9fed-001143a055f9")]
[NativeTypeName("struct ID2D1SimplifiedGeometrySink : IUnknown")]
[NativeInheritance("IUnknown")]
public unsafe partial struct ID2D1SimplifiedGeometrySink
{
public static ref readonly Guid IID_ID2D1SimplifiedGeometrySink
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
ReadOnlySpan<byte> data = new byte[] {
0x9E, 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_ID2D1SimplifiedGeometrySink));
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="ID2D1SimplifiedGeometrySink::SetFillMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void SetFillMode(FillMode fillMode)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, FillMode, void>)(lpVtbl[3]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), fillMode);
}
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::SetSegmentFlags"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetSegmentFlags(PathSegment vertexFlags)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, PathSegment, void>)(lpVtbl[4]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), vertexFlags);
}
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::BeginFigure"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void BeginFigure(System.Drawing.PointF* startPoint, FigureBegin figureBegin)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, System.Drawing.PointF*, FigureBegin, void>)(lpVtbl[5]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), startPoint, figureBegin);
}
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::AddLines"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public void AddLines(System.Drawing.PointF** points, uint pointsCount)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, System.Drawing.PointF**, uint, void>)(lpVtbl[6]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), points, pointsCount);
}
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::AddBeziers"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void AddBeziers(BezierSegment* beziers, uint beziersCount)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, BezierSegment*, uint, void>)(lpVtbl[7]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), beziers, beziersCount);
}
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::EndFigure"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public void EndFigure(FigureEnd figureEnd)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, FigureEnd, void>)(lpVtbl[8]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), figureEnd);
}
/// <include file='../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::Close"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Close()
{
return ((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this));
}
}
#endregion Com Types

23244
src/Vortice.Win32/Generated/Graphics/Direct2D.cs
View File

File diff suppressed because it is too large Load Diff

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1AnalysisTransform.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

148
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Bitmap.cs Normal file
View File

@@ -0,0 +1,148 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, System.Drawing.Size>)(lpVtbl[5]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1Bitmap::GetPixelFormat"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[6]))((ID2D1Bitmap*)Unsafe.AsPointer(ref this), &result);
}
/// <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(System.Drawing.Point* destPoint, ID2D1Bitmap* bitmap, Common.RectU* srcRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, System.Drawing.Point*, 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(System.Drawing.Point* destPoint, ID2D1RenderTarget* renderTarget, Common.RectU* srcRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap*, System.Drawing.Point*, 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);
}
}

188
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Bitmap1.cs Normal file
View File

@@ -0,0 +1,188 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Bitmap.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, System.Drawing.SizeF>)(lpVtbl[4]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Bitmap.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, System.Drawing.Size>)(lpVtbl[5]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Bitmap.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[6]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1Bitmap.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, float*, float*, void>)(lpVtbl[7]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1Bitmap.CopyFromBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CopyFromBitmap(System.Drawing.Point* destPoint, ID2D1Bitmap* bitmap, Common.RectU* srcRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, System.Drawing.Point*, ID2D1Bitmap*, Common.RectU*, int>)(lpVtbl[8]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), destPoint, bitmap, srcRect);
}
/// <inheritdoc cref="ID2D1Bitmap.CopyFromRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult CopyFromRenderTarget(System.Drawing.Point* destPoint, ID2D1RenderTarget* renderTarget, Common.RectU* srcRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, System.Drawing.Point*, ID2D1RenderTarget*, Common.RectU*, int>)(lpVtbl[9]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), destPoint, renderTarget, srcRect);
}
/// <inheritdoc cref="ID2D1Bitmap.CopyFromMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CopyFromMemory(Common.RectU* dstRect, void* srcData, uint pitch)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, Common.RectU*, void*, uint, int>)(lpVtbl[10]))((ID2D1Bitmap1*)Unsafe.AsPointer(ref this), dstRect, srcData, pitch);
}
/// <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 BitmapOptions GetOptions()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Bitmap1*, 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));
}
}

187
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1BitmapBrush.cs Normal file
View File

@@ -0,0 +1,187 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetOpacity(float opacity)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, float, void>)(lpVtbl[4]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), opacity);
}
/// <inheritdoc cref="ID2D1Brush.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public float GetOpacity()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, float>)(lpVtbl[6]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Brush.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <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 ExtendMode GetExtendModeX()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ExtendMode>)(lpVtbl[12]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::GetExtendModeY"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public ExtendMode GetExtendModeY()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, ExtendMode>)(lpVtbl[13]))((ID2D1BitmapBrush*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1BitmapBrush::GetInterpolationMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public BitmapInterpolationMode GetInterpolationMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush*, 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);
}
}

203
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1BitmapBrush1.cs Normal file
View File

@@ -0,0 +1,203 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetOpacity(float opacity)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, float, void>)(lpVtbl[4]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), opacity);
}
/// <inheritdoc cref="ID2D1Brush.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public float GetOpacity()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, float>)(lpVtbl[6]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Brush.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1BitmapBrush.SetExtendModeX" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public void SetExtendModeX(ExtendMode extendModeX)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ExtendMode, void>)(lpVtbl[8]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), extendModeX);
}
/// <inheritdoc cref="ID2D1BitmapBrush.SetExtendModeY" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public void SetExtendModeY(ExtendMode extendModeY)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ExtendMode, void>)(lpVtbl[9]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), extendModeY);
}
/// <inheritdoc cref="ID2D1BitmapBrush.SetInterpolationMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public void SetInterpolationMode(BitmapInterpolationMode interpolationMode)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, BitmapInterpolationMode, void>)(lpVtbl[10]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), interpolationMode);
}
/// <inheritdoc cref="ID2D1BitmapBrush.SetBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public void SetBitmap(ID2D1Bitmap* bitmap)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ID2D1Bitmap*, void>)(lpVtbl[11]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), bitmap);
}
/// <inheritdoc cref="ID2D1BitmapBrush.GetExtendModeX" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public ExtendMode GetExtendModeX()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ExtendMode>)(lpVtbl[12]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1BitmapBrush.GetExtendModeY" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public ExtendMode GetExtendModeY()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ExtendMode>)(lpVtbl[13]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1BitmapBrush.GetInterpolationMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public BitmapInterpolationMode GetInterpolationMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, BitmapInterpolationMode>)(lpVtbl[14]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1BitmapBrush.GetBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(15)]
public void GetBitmap(ID2D1Bitmap** bitmap)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, ID2D1Bitmap**, void>)(lpVtbl[15]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this), bitmap);
}
/// <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 InterpolationMode GetInterpolationMode1()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapBrush1*, InterpolationMode>)(lpVtbl[17]))((ID2D1BitmapBrush1*)Unsafe.AsPointer(ref this));
}
}

524
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1BitmapRenderTarget.cs Normal file
View File

@@ -0,0 +1,524 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1BitmapRenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1BitmapRenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1BitmapRenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1BitmapRenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1BitmapRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1BitmapRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, AntialiasMode>)(lpVtbl[33]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, void>)(lpVtbl[41]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, void>)(lpVtbl[46]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, void>)(lpVtbl[48]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, float, float, void>)(lpVtbl[51]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, float*, float*, void>)(lpVtbl[52]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, uint>)(lpVtbl[55]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BitmapRenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1BitmapRenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1BlendTransform.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1TransformNode.GetInputCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public uint GetInputCount()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, uint>)(lpVtbl[3]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1ConcreteTransform.SetOutputBuffer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, BufferPrecision, ChannelDepth, int>)(lpVtbl[4]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
}
/// <inheritdoc cref="ID2D1ConcreteTransform.SetCached" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetCached(Bool32 isCached)
{
((delegate* unmanaged[Stdcall]<ID2D1BlendTransform*, Bool32, void>)(lpVtbl[5]))((ID2D1BlendTransform*)Unsafe.AsPointer(ref this), isCached);
}
/// <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);
}
}

139
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1BorderTransform.cs Normal file
View File

@@ -0,0 +1,139 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1TransformNode.GetInputCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public uint GetInputCount()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, uint>)(lpVtbl[3]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1ConcreteTransform.SetOutputBuffer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult SetOutputBuffer(BufferPrecision bufferPrecision, ChannelDepth channelDepth)
{
return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, BufferPrecision, ChannelDepth, int>)(lpVtbl[4]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this), bufferPrecision, channelDepth);
}
/// <inheritdoc cref="ID2D1ConcreteTransform.SetCached" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetCached(Bool32 isCached)
{
((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, Bool32, void>)(lpVtbl[5]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this), isCached);
}
/// <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 ExtendMode GetExtendModeX()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, ExtendMode>)(lpVtbl[8]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1BorderTransform::GetExtendModeY"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public ExtendMode GetExtendModeY()
{
return ((delegate* unmanaged[Stdcall]<ID2D1BorderTransform*, ExtendMode>)(lpVtbl[9]))((ID2D1BorderTransform*)Unsafe.AsPointer(ref this));
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1BoundsAdjustmentTransform.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Brush.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

115
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ColorContext.cs Normal file
View File

@@ -0,0 +1,115 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 ColorSpace GetColorSpace()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext*, 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);
}
}

139
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ColorContext1.cs Normal file
View File

@@ -0,0 +1,139 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1ColorContext.GetColorSpace" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public ColorSpace GetColorSpace()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, ColorSpace>)(lpVtbl[4]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1ColorContext.GetProfileSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public uint GetProfileSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, uint>)(lpVtbl[5]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1ColorContext.GetProfile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult GetProfile(byte* profile, uint profileSize)
{
return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, byte*, uint, int>)(lpVtbl[6]))((ID2D1ColorContext1*)Unsafe.AsPointer(ref this), profile, profileSize);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1ColorContext1::GetColorContextType"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public ColorContextType GetColorContextType()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ColorContext1*, 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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandList.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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));
}
}

283
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandSink.cs Normal file
View File

@@ -0,0 +1,283 @@
// ------------------------------------------------------------------------------
// <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;
/// <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));
}
}

291
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandSink1.cs Normal file
View File

@@ -0,0 +1,291 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

315
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandSink2.cs Normal file
View File

@@ -0,0 +1,315 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1CommandSink.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult BeginDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[3]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult EndDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[4]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult SetAntialiasMode(AntialiasMode antialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, AntialiasMode, int>)(lpVtbl[5]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ulong, ulong, int>)(lpVtbl[6]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, TextAntialiasMode, int>)(lpVtbl[7]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[8]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult SetTransform(Matrix3x2* transform)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Matrix3x2*, int>)(lpVtbl[9]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, PrimitiveBlend, int>)(lpVtbl[10]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult SetUnitMode(UnitMode unitMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, UnitMode, int>)(lpVtbl[11]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1CommandSink.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Clear(Common.ColorF* color)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, Common.ColorF*, int>)(lpVtbl[12]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[13]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[14]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[17]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[18]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[19]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[20]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[21]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[22]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, Common.RectF*, AntialiasMode, int>)(lpVtbl[24]))((ID2D1CommandSink2*)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]<ID2D1CommandSink2*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[25]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), layerParameters1, layer);
}
/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult PopAxisAlignedClip()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[26]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult PopLayer()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, int>)(lpVtbl[27]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink2*, PrimitiveBlend, int>)(lpVtbl[28]))((ID2D1CommandSink2*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <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);
}
}

323
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandSink3.cs Normal file
View File

@@ -0,0 +1,323 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1CommandSink.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult BeginDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[3]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult EndDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[4]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult SetAntialiasMode(AntialiasMode antialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, AntialiasMode, int>)(lpVtbl[5]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ulong, ulong, int>)(lpVtbl[6]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, TextAntialiasMode, int>)(lpVtbl[7]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[8]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult SetTransform(Matrix3x2* transform)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Matrix3x2*, int>)(lpVtbl[9]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, PrimitiveBlend, int>)(lpVtbl[10]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult SetUnitMode(UnitMode unitMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, UnitMode, int>)(lpVtbl[11]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1CommandSink.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Clear(Common.ColorF* color)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, Common.ColorF*, int>)(lpVtbl[12]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[13]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[14]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[17]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[18]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[19]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[20]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[21]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[22]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, Common.RectF*, AntialiasMode, int>)(lpVtbl[24]))((ID2D1CommandSink3*)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]<ID2D1CommandSink3*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[25]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), layerParameters1, layer);
}
/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult PopAxisAlignedClip()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[26]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult PopLayer()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, int>)(lpVtbl[27]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, PrimitiveBlend, int>)(lpVtbl[28]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(29)]
public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[29]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1GradientMesh*, int>)(lpVtbl[30]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), gradientMesh);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink3*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[31]))((ID2D1CommandSink3*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
}
/// <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);
}
}

331
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandSink4.cs Normal file
View File

@@ -0,0 +1,331 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1CommandSink.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult BeginDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[3]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult EndDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[4]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult SetAntialiasMode(AntialiasMode antialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, AntialiasMode, int>)(lpVtbl[5]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ulong, ulong, int>)(lpVtbl[6]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, TextAntialiasMode, int>)(lpVtbl[7]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[8]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult SetTransform(Matrix3x2* transform)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Matrix3x2*, int>)(lpVtbl[9]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, PrimitiveBlend, int>)(lpVtbl[10]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult SetUnitMode(UnitMode unitMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, UnitMode, int>)(lpVtbl[11]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1CommandSink.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Clear(Common.ColorF* color)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, Common.ColorF*, int>)(lpVtbl[12]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[13]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[14]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[17]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[18]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[19]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[20]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[21]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[22]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, Common.RectF*, AntialiasMode, int>)(lpVtbl[24]))((ID2D1CommandSink4*)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]<ID2D1CommandSink4*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[25]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), layerParameters1, layer);
}
/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult PopAxisAlignedClip()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[26]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult PopLayer()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, int>)(lpVtbl[27]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, PrimitiveBlend, int>)(lpVtbl[28]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(29)]
public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[29]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1GradientMesh*, int>)(lpVtbl[30]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), gradientMesh);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink4*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[31]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1CommandSink4*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, int>)(lpVtbl[32]))((ID2D1CommandSink4*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
}
/// <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);
}
}

339
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1CommandSink5.cs Normal file
View File

@@ -0,0 +1,339 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1CommandSink.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult BeginDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[3]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult EndDraw()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[4]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult SetAntialiasMode(AntialiasMode antialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, AntialiasMode, int>)(lpVtbl[5]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ulong, ulong, int>)(lpVtbl[6]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, TextAntialiasMode, int>)(lpVtbl[7]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, Graphics.DirectWrite.IDWriteRenderingParams*, int>)(lpVtbl[8]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1CommandSink.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult SetTransform(Matrix3x2* transform)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Matrix3x2*, int>)(lpVtbl[9]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1CommandSink.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, PrimitiveBlend, int>)(lpVtbl[10]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult SetUnitMode(UnitMode unitMode)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, UnitMode, int>)(lpVtbl[11]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1CommandSink.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Clear(Common.ColorF* color)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, Common.ColorF*, int>)(lpVtbl[12]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, int>)(lpVtbl[13]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[14]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[15]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, int>)(lpVtbl[16]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, int>)(lpVtbl[17]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, int>)(lpVtbl[18]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1GdiMetafile*, System.Drawing.PointF*, int>)(lpVtbl[19]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1Mesh*, ID2D1Brush*, int>)(lpVtbl[20]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1Bitmap*, ID2D1Brush*, Common.RectF*, Common.RectF*, int>)(lpVtbl[21]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, int>)(lpVtbl[22]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, Common.RectF*, ID2D1Brush*, int>)(lpVtbl[23]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, Common.RectF*, AntialiasMode, int>)(lpVtbl[24]))((ID2D1CommandSink5*)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]<ID2D1CommandSink5*, LayerParameters1*, ID2D1Layer*, int>)(lpVtbl[25]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), layerParameters1, layer);
}
/// <inheritdoc cref="ID2D1CommandSink.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult PopAxisAlignedClip()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[26]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult PopLayer()
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, int>)(lpVtbl[27]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1CommandSink1.SetPrimitiveBlend1" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult SetPrimitiveBlend1(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, PrimitiveBlend, int>)(lpVtbl[28]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(29)]
public HResult DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, int>)(lpVtbl[29]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public HResult DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1GradientMesh*, int>)(lpVtbl[30]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), gradientMesh);
}
/// <inheritdoc cref="ID2D1CommandSink2.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public HResult DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, int>)(lpVtbl[31]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1CommandSink5*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, int>)(lpVtbl[32]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
}
/// <inheritdoc cref="ID2D1CommandSink4.SetPrimitiveBlend2" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public HResult SetPrimitiveBlend2(PrimitiveBlend primitiveBlend)
{
return ((delegate* unmanaged[Stdcall]<ID2D1CommandSink5*, PrimitiveBlend, int>)(lpVtbl[33]))((ID2D1CommandSink5*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <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);
}
}

139
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ComputeInfo.cs Normal file
View File

@@ -0,0 +1,139 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

131
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ComputeTransform.cs Normal file
View File

@@ -0,0 +1,131 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1TransformNode.GetInputCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public uint GetInputCount()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, uint>)(lpVtbl[3]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Transform.MapOutputRectToInputRects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, RawRect*, RawRect*, uint, int>)(lpVtbl[4]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
}
/// <inheritdoc cref="ID2D1Transform.MapInputRectsToOutputRect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
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[5]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
}
/// <inheritdoc cref="ID2D1Transform.MapInvalidRect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1ComputeTransform*, uint, RawRect*, RawRect*, int>)(lpVtbl[6]))((ID2D1ComputeTransform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
}
/// <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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ConcreteTransform.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

524
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DCRenderTarget.cs Normal file
View File

@@ -0,0 +1,524 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1DCRenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1DCRenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DCRenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DCRenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DCRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1DCRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, AntialiasMode>)(lpVtbl[33]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, void>)(lpVtbl[41]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, void>)(lpVtbl[46]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, void>)(lpVtbl[48]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, float, float, void>)(lpVtbl[51]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, float*, float*, void>)(lpVtbl[52]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, uint>)(lpVtbl[55]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DCRenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1DCRenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

147
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device1.cs Normal file
View File

@@ -0,0 +1,147 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Device1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device1*)Unsafe.AsPointer(ref this), options, deviceContext);
}
/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetMaximumTextureMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device1*, ulong, void>)(lpVtbl[5]))((ID2D1Device1*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public ulong GetMaximumTextureMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, ulong>)(lpVtbl[6]))((ID2D1Device1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device.ClearResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void ClearResources(uint millisecondsSinceUse)
{
((delegate* unmanaged[Stdcall]<ID2D1Device1*, uint, void>)(lpVtbl[7]))((ID2D1Device1*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1Device1::GetRenderingPriority"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public RenderingPriority GetRenderingPriority()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device1*, 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);
}
}

171
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device2.cs Normal file
View File

@@ -0,0 +1,171 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Device2*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device2*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device2*)Unsafe.AsPointer(ref this), options, deviceContext);
}
/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetMaximumTextureMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device2*, ulong, void>)(lpVtbl[5]))((ID2D1Device2*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public ulong GetMaximumTextureMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, ulong>)(lpVtbl[6]))((ID2D1Device2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device.ClearResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void ClearResources(uint millisecondsSinceUse)
{
((delegate* unmanaged[Stdcall]<ID2D1Device2*, uint, void>)(lpVtbl[7]))((ID2D1Device2*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
}
/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public RenderingPriority GetRenderingPriority()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, RenderingPriority>)(lpVtbl[8]))((ID2D1Device2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public void SetRenderingPriority(RenderingPriority renderingPriority)
{
((delegate* unmanaged[Stdcall]<ID2D1Device2*, RenderingPriority, void>)(lpVtbl[9]))((ID2D1Device2*)Unsafe.AsPointer(ref this), renderingPriority);
}
/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device2*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[10]))((ID2D1Device2*)Unsafe.AsPointer(ref this), options, deviceContext1);
}
/// <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);
}
}

179
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device3.cs Normal file
View File

@@ -0,0 +1,179 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Device3*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device3*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext);
}
/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetMaximumTextureMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device3*, ulong, void>)(lpVtbl[5]))((ID2D1Device3*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public ulong GetMaximumTextureMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, ulong>)(lpVtbl[6]))((ID2D1Device3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device.ClearResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void ClearResources(uint millisecondsSinceUse)
{
((delegate* unmanaged[Stdcall]<ID2D1Device3*, uint, void>)(lpVtbl[7]))((ID2D1Device3*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
}
/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public RenderingPriority GetRenderingPriority()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, RenderingPriority>)(lpVtbl[8]))((ID2D1Device3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public void SetRenderingPriority(RenderingPriority renderingPriority)
{
((delegate* unmanaged[Stdcall]<ID2D1Device3*, RenderingPriority, void>)(lpVtbl[9]))((ID2D1Device3*)Unsafe.AsPointer(ref this), renderingPriority);
}
/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[10]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext1);
}
/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[11]))((ID2D1Device3*)Unsafe.AsPointer(ref this), options, deviceContext2);
}
/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
{
((delegate* unmanaged[Stdcall]<ID2D1Device3*, ID2D1Bitmap*, void>)(lpVtbl[12]))((ID2D1Device3*)Unsafe.AsPointer(ref this), bitmap);
}
/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device3*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[13]))((ID2D1Device3*)Unsafe.AsPointer(ref this), dxgiDevice);
}
/// <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);
}
}

203
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device4.cs Normal file
View File

@@ -0,0 +1,203 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Device4*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device4*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext);
}
/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetMaximumTextureMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device4*, ulong, void>)(lpVtbl[5]))((ID2D1Device4*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public ulong GetMaximumTextureMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, ulong>)(lpVtbl[6]))((ID2D1Device4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device.ClearResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void ClearResources(uint millisecondsSinceUse)
{
((delegate* unmanaged[Stdcall]<ID2D1Device4*, uint, void>)(lpVtbl[7]))((ID2D1Device4*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
}
/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public RenderingPriority GetRenderingPriority()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, RenderingPriority>)(lpVtbl[8]))((ID2D1Device4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public void SetRenderingPriority(RenderingPriority renderingPriority)
{
((delegate* unmanaged[Stdcall]<ID2D1Device4*, RenderingPriority, void>)(lpVtbl[9]))((ID2D1Device4*)Unsafe.AsPointer(ref this), renderingPriority);
}
/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[10]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext1);
}
/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[11]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext2);
}
/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
{
((delegate* unmanaged[Stdcall]<ID2D1Device4*, ID2D1Bitmap*, void>)(lpVtbl[12]))((ID2D1Device4*)Unsafe.AsPointer(ref this), bitmap);
}
/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[13]))((ID2D1Device4*)Unsafe.AsPointer(ref this), dxgiDevice);
}
/// <inheritdoc cref="ID2D1Device3.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device4*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[14]))((ID2D1Device4*)Unsafe.AsPointer(ref this), options, deviceContext3);
}
/// <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));
}
}

211
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device5.cs Normal file
View File

@@ -0,0 +1,211 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Device5*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device5*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext);
}
/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetMaximumTextureMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong, void>)(lpVtbl[5]))((ID2D1Device5*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public ulong GetMaximumTextureMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong>)(lpVtbl[6]))((ID2D1Device5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device.ClearResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void ClearResources(uint millisecondsSinceUse)
{
((delegate* unmanaged[Stdcall]<ID2D1Device5*, uint, void>)(lpVtbl[7]))((ID2D1Device5*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
}
/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public RenderingPriority GetRenderingPriority()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, RenderingPriority>)(lpVtbl[8]))((ID2D1Device5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public void SetRenderingPriority(RenderingPriority renderingPriority)
{
((delegate* unmanaged[Stdcall]<ID2D1Device5*, RenderingPriority, void>)(lpVtbl[9]))((ID2D1Device5*)Unsafe.AsPointer(ref this), renderingPriority);
}
/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[10]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext1);
}
/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[11]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext2);
}
/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
{
((delegate* unmanaged[Stdcall]<ID2D1Device5*, ID2D1Bitmap*, void>)(lpVtbl[12]))((ID2D1Device5*)Unsafe.AsPointer(ref this), bitmap);
}
/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[13]))((ID2D1Device5*)Unsafe.AsPointer(ref this), dxgiDevice);
}
/// <inheritdoc cref="ID2D1Device3.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[14]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext3);
}
/// <inheritdoc cref="ID2D1Device4.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(15)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext4** deviceContext4)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, DeviceContextOptions, ID2D1DeviceContext4**, int>)(lpVtbl[15]))((ID2D1Device5*)Unsafe.AsPointer(ref this), options, deviceContext4);
}
/// <inheritdoc cref="ID2D1Device4.SetMaximumColorGlyphCacheMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void SetMaximumColorGlyphCacheMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong, void>)(lpVtbl[16]))((ID2D1Device5*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device4.GetMaximumColorGlyphCacheMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public ulong GetMaximumColorGlyphCacheMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device5*, ulong>)(lpVtbl[17]))((ID2D1Device5*)Unsafe.AsPointer(ref this));
}
/// <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);
}
}

219
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Device6.cs Normal file
View File

@@ -0,0 +1,219 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1Device6*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1Device6*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Device.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext** deviceContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext**, int>)(lpVtbl[4]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext);
}
/// <inheritdoc cref="ID2D1Device.SetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetMaximumTextureMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong, void>)(lpVtbl[5]))((ID2D1Device6*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device.GetMaximumTextureMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public ulong GetMaximumTextureMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong>)(lpVtbl[6]))((ID2D1Device6*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device.ClearResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void ClearResources(uint millisecondsSinceUse)
{
((delegate* unmanaged[Stdcall]<ID2D1Device6*, uint, void>)(lpVtbl[7]))((ID2D1Device6*)Unsafe.AsPointer(ref this), millisecondsSinceUse);
}
/// <inheritdoc cref="ID2D1Device1.GetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public RenderingPriority GetRenderingPriority()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, RenderingPriority>)(lpVtbl[8]))((ID2D1Device6*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device1.SetRenderingPriority" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public void SetRenderingPriority(RenderingPriority renderingPriority)
{
((delegate* unmanaged[Stdcall]<ID2D1Device6*, RenderingPriority, void>)(lpVtbl[9]))((ID2D1Device6*)Unsafe.AsPointer(ref this), renderingPriority);
}
/// <inheritdoc cref="ID2D1Device1.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext1** deviceContext1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext1**, int>)(lpVtbl[10]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext1);
}
/// <inheritdoc cref="ID2D1Device2.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext2** deviceContext2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext2**, int>)(lpVtbl[11]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext2);
}
/// <inheritdoc cref="ID2D1Device2.FlushDeviceContexts" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public void FlushDeviceContexts(ID2D1Bitmap* bitmap)
{
((delegate* unmanaged[Stdcall]<ID2D1Device6*, ID2D1Bitmap*, void>)(lpVtbl[12]))((ID2D1Device6*)Unsafe.AsPointer(ref this), bitmap);
}
/// <inheritdoc cref="ID2D1Device2.GetDxgiDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult GetDxgiDevice(Graphics.Dxgi.IDXGIDevice** dxgiDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, Graphics.Dxgi.IDXGIDevice**, int>)(lpVtbl[13]))((ID2D1Device6*)Unsafe.AsPointer(ref this), dxgiDevice);
}
/// <inheritdoc cref="ID2D1Device3.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext3** deviceContext3)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext3**, int>)(lpVtbl[14]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext3);
}
/// <inheritdoc cref="ID2D1Device4.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(15)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext4** deviceContext4)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext4**, int>)(lpVtbl[15]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext4);
}
/// <inheritdoc cref="ID2D1Device4.SetMaximumColorGlyphCacheMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void SetMaximumColorGlyphCacheMemory(ulong maximumInBytes)
{
((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong, void>)(lpVtbl[16]))((ID2D1Device6*)Unsafe.AsPointer(ref this), maximumInBytes);
}
/// <inheritdoc cref="ID2D1Device4.GetMaximumColorGlyphCacheMemory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public ulong GetMaximumColorGlyphCacheMemory()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, ulong>)(lpVtbl[17]))((ID2D1Device6*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Device5.CreateDeviceContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateDeviceContext(DeviceContextOptions options, ID2D1DeviceContext5** deviceContext5)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Device6*, DeviceContextOptions, ID2D1DeviceContext5**, int>)(lpVtbl[18]))((ID2D1Device6*)Unsafe.AsPointer(ref this), options, deviceContext5);
}
/// <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);
}
}

796
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext.cs Normal file
View File

@@ -0,0 +1,796 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, AntialiasMode>)(lpVtbl[33]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, void>)(lpVtbl[41]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, void>)(lpVtbl[46]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, void>)(lpVtbl[48]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, float, float, void>)(lpVtbl[51]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, float*, float*, void>)(lpVtbl[52]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, uint>)(lpVtbl[55]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1DeviceContext*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1DeviceContext::CreateBitmap"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(57)]
public HResult CreateBitmap(System.Drawing.Size size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, System.Drawing.Size, 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 PrimitiveBlend GetPrimitiveBlend()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, 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 UnitMode GetUnitMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext*, 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);
}
}

820
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext1.cs Normal file
View File

@@ -0,0 +1,820 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, AntialiasMode>)(lpVtbl[33]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, void>)(lpVtbl[41]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, void>)(lpVtbl[46]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, void>)(lpVtbl[48]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, float, float, void>)(lpVtbl[51]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, float*, float*, void>)(lpVtbl[52]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, uint>)(lpVtbl[55]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(57)]
public HResult CreateBitmap(System.Drawing.Size size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, System.Drawing.Size, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[57]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(58)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[58]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(59)]
public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[59]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(60)]
public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[60]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), filename, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(61)]
public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[61]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(62)]
public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[62]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(63)]
public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Guid*, ID2D1Effect**, int>)(lpVtbl[63]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effectId, effect);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[64]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(65)]
public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[65]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(66)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[66]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(67)]
public HResult CreateCommandList(ID2D1CommandList** commandList)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1CommandList**, int>)(lpVtbl[67]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), commandList);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(68)]
public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[68]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), format);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(69)]
public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, BufferPrecision, Bool32>)(lpVtbl[69]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bufferPrecision);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(70)]
public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[70]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, localBounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(71)]
public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[71]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, worldBounds);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[72]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(73)]
public void GetDevice(ID2D1Device** device)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Device**, void>)(lpVtbl[73]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), device);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(74)]
public void SetTarget(ID2D1Image* image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image*, void>)(lpVtbl[74]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(75)]
public void GetTarget(ID2D1Image** image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Image**, void>)(lpVtbl[75]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(76)]
public void SetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RenderingControls*, void>)(lpVtbl[76]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(77)]
public void GetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, RenderingControls*, void>)(lpVtbl[77]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(78)]
public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, PrimitiveBlend, void>)(lpVtbl[78]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(79)]
public PrimitiveBlend GetPrimitiveBlend()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, PrimitiveBlend>)(lpVtbl[79]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(80)]
public void SetUnitMode(UnitMode unitMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, UnitMode, void>)(lpVtbl[80]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(81)]
public UnitMode GetUnitMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, UnitMode>)(lpVtbl[81]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[82]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[83]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(84)]
public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[84]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[85]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(86)]
public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[86]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(87)]
public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[87]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(88)]
public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, uint*, int>)(lpVtbl[88]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effect, rectangleCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(89)]
public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext1*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[89]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext1*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[90]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(91)]
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[91]))((ID2D1DeviceContext1*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
}
/// <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);
}
}

908
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext2.cs Normal file
View File

@@ -0,0 +1,908 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, AntialiasMode>)(lpVtbl[33]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, void>)(lpVtbl[41]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, void>)(lpVtbl[46]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, void>)(lpVtbl[48]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, float, float, void>)(lpVtbl[51]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, float*, float*, void>)(lpVtbl[52]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, uint>)(lpVtbl[55]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(57)]
public HResult CreateBitmap(System.Drawing.Size size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, System.Drawing.Size, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[57]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(58)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[58]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(59)]
public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[59]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(60)]
public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[60]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), filename, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(61)]
public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[61]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(62)]
public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[62]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(63)]
public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Guid*, ID2D1Effect**, int>)(lpVtbl[63]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effectId, effect);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[64]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(65)]
public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[65]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(66)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[66]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(67)]
public HResult CreateCommandList(ID2D1CommandList** commandList)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1CommandList**, int>)(lpVtbl[67]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), commandList);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(68)]
public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[68]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), format);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(69)]
public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, BufferPrecision, Bool32>)(lpVtbl[69]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bufferPrecision);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(70)]
public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[70]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, localBounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(71)]
public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[71]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, worldBounds);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[72]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(73)]
public void GetDevice(ID2D1Device** device)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Device**, void>)(lpVtbl[73]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), device);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(74)]
public void SetTarget(ID2D1Image* image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image*, void>)(lpVtbl[74]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(75)]
public void GetTarget(ID2D1Image** image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Image**, void>)(lpVtbl[75]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(76)]
public void SetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RenderingControls*, void>)(lpVtbl[76]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(77)]
public void GetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, RenderingControls*, void>)(lpVtbl[77]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(78)]
public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, PrimitiveBlend, void>)(lpVtbl[78]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(79)]
public PrimitiveBlend GetPrimitiveBlend()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, PrimitiveBlend>)(lpVtbl[79]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(80)]
public void SetUnitMode(UnitMode unitMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, UnitMode, void>)(lpVtbl[80]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(81)]
public UnitMode GetUnitMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, UnitMode>)(lpVtbl[81]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[82]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[83]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(84)]
public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[84]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[85]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(86)]
public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[86]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(87)]
public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[87]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(88)]
public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, uint*, int>)(lpVtbl[88]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effect, rectangleCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(89)]
public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[89]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext2*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[90]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(91)]
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[91]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(92)]
public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[92]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
}
/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(93)]
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[93]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
}
/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(94)]
public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext2*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[94]))((ID2D1DeviceContext2*)Unsafe.AsPointer(ref this), geometryRealization, brush);
}
/// <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);
}
}

924
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext3.cs Normal file
View File

@@ -0,0 +1,924 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, AntialiasMode>)(lpVtbl[33]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, void>)(lpVtbl[41]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, void>)(lpVtbl[46]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, void>)(lpVtbl[48]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, float, float, void>)(lpVtbl[51]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, float*, float*, void>)(lpVtbl[52]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, uint>)(lpVtbl[55]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(57)]
public HResult CreateBitmap(System.Drawing.Size size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, System.Drawing.Size, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[57]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(58)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[58]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(59)]
public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[59]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(60)]
public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[60]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), filename, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(61)]
public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[61]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(62)]
public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[62]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(63)]
public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Guid*, ID2D1Effect**, int>)(lpVtbl[63]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effectId, effect);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[64]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(65)]
public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[65]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(66)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[66]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(67)]
public HResult CreateCommandList(ID2D1CommandList** commandList)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1CommandList**, int>)(lpVtbl[67]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), commandList);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(68)]
public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[68]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), format);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(69)]
public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, BufferPrecision, Bool32>)(lpVtbl[69]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bufferPrecision);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(70)]
public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[70]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, localBounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(71)]
public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[71]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, worldBounds);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[72]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(73)]
public void GetDevice(ID2D1Device** device)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Device**, void>)(lpVtbl[73]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), device);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(74)]
public void SetTarget(ID2D1Image* image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image*, void>)(lpVtbl[74]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(75)]
public void GetTarget(ID2D1Image** image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Image**, void>)(lpVtbl[75]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(76)]
public void SetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RenderingControls*, void>)(lpVtbl[76]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(77)]
public void GetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, RenderingControls*, void>)(lpVtbl[77]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(78)]
public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, PrimitiveBlend, void>)(lpVtbl[78]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(79)]
public PrimitiveBlend GetPrimitiveBlend()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, PrimitiveBlend>)(lpVtbl[79]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(80)]
public void SetUnitMode(UnitMode unitMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, UnitMode, void>)(lpVtbl[80]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(81)]
public UnitMode GetUnitMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, UnitMode>)(lpVtbl[81]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[82]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[83]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(84)]
public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[84]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[85]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(86)]
public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[86]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(87)]
public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[87]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(88)]
public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, uint*, int>)(lpVtbl[88]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effect, rectangleCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(89)]
public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[89]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[90]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(91)]
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[91]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(92)]
public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[92]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
}
/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(93)]
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[93]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
}
/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(94)]
public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[94]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), geometryRealization, brush);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(95)]
public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[95]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), startPoint, ink);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateInkStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(96)]
public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[96]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(97)]
public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[97]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[98]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[99]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext3*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[100]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
}
/// <inheritdoc cref="ID2D1DeviceContext2.GetGradientMeshWorldBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(101)]
public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[101]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
}
/// <inheritdoc cref="ID2D1DeviceContext2.DrawInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(102)]
public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[102]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
}
/// <inheritdoc cref="ID2D1DeviceContext2.DrawGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(103)]
public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GradientMesh*, void>)(lpVtbl[103]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gradientMesh);
}
/// <inheritdoc cref="ID2D1DeviceContext2.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(104)]
public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[104]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateTransformedImageSource" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(105)]
public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext3*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[105]))((ID2D1DeviceContext3*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
}
/// <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);
}
}

980
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext4.cs Normal file
View File

@@ -0,0 +1,980 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, AntialiasMode>)(lpVtbl[33]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, void>)(lpVtbl[41]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, void>)(lpVtbl[46]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, void>)(lpVtbl[48]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, float, float, void>)(lpVtbl[51]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, float*, float*, void>)(lpVtbl[52]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, uint>)(lpVtbl[55]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(57)]
public HResult CreateBitmap(System.Drawing.Size size, void* sourceData, uint pitch, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, System.Drawing.Size, void*, uint, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[57]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), size, sourceData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(58)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[58]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(59)]
public HResult CreateColorContext(ColorSpace space, byte* profile, uint profileSize, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[59]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), space, profile, profileSize, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromFilename" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(60)]
public HResult CreateColorContextFromFilename(ushort* filename, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[60]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), filename, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateColorContextFromWicColorContext" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(61)]
public HResult CreateColorContextFromWicColorContext(Graphics.Imaging.IWICColorContext* wicColorContext, ID2D1ColorContext** colorContext)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[61]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicColorContext, colorContext);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapFromDxgiSurface" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(62)]
public HResult CreateBitmapFromDxgiSurface(Graphics.Dxgi.IDXGISurface* surface, BitmapProperties1* bitmapProperties, ID2D1Bitmap1** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Dxgi.IDXGISurface*, BitmapProperties1*, ID2D1Bitmap1**, int>)(lpVtbl[62]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), surface, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(63)]
public HResult CreateEffect(Guid* effectId, ID2D1Effect** effect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Guid*, ID2D1Effect**, int>)(lpVtbl[63]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effectId, effect);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, GradientStop*, uint, ColorSpace, ColorSpace, BufferPrecision, ExtendMode, ColorInterpolationMode, ID2D1GradientStopCollection1**, int>)(lpVtbl[64]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateImageBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(65)]
public HResult CreateImageBrush(ID2D1Image* image, ImageBrushProperties* imageBrushProperties, BrushProperties* brushProperties, ID2D1ImageBrush** imageBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, ImageBrushProperties*, BrushProperties*, ID2D1ImageBrush**, int>)(lpVtbl[65]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, imageBrushProperties, brushProperties, imageBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(66)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties1* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush1** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Bitmap*, BitmapBrushProperties1*, BrushProperties*, ID2D1BitmapBrush1**, int>)(lpVtbl[66]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1DeviceContext.CreateCommandList" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(67)]
public HResult CreateCommandList(ID2D1CommandList** commandList)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1CommandList**, int>)(lpVtbl[67]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), commandList);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsDxgiFormatSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(68)]
public Bool32 IsDxgiFormatSupported(Graphics.Dxgi.Common.Format format)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, Graphics.Dxgi.Common.Format, Bool32>)(lpVtbl[68]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), format);
}
/// <inheritdoc cref="ID2D1DeviceContext.IsBufferPrecisionSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(69)]
public Bool32 IsBufferPrecisionSupported(BufferPrecision bufferPrecision)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, BufferPrecision, Bool32>)(lpVtbl[69]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bufferPrecision);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageLocalBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(70)]
public HResult GetImageLocalBounds(ID2D1Image* image, Common.RectF* localBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[70]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, localBounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetImageWorldBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(71)]
public HResult GetImageWorldBounds(ID2D1Image* image, Common.RectF* worldBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, Common.RectF*, int>)(lpVtbl[71]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, worldBounds);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.MeasuringMode, Common.RectF*, int>)(lpVtbl[72]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, measuringMode, bounds);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(73)]
public void GetDevice(ID2D1Device** device)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Device**, void>)(lpVtbl[73]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), device);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(74)]
public void SetTarget(ID2D1Image* image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image*, void>)(lpVtbl[74]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(75)]
public void GetTarget(ID2D1Image** image)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Image**, void>)(lpVtbl[75]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(76)]
public void SetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RenderingControls*, void>)(lpVtbl[76]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetRenderingControls" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(77)]
public void GetRenderingControls(RenderingControls* renderingControls)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, RenderingControls*, void>)(lpVtbl[77]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderingControls);
}
/// <inheritdoc cref="ID2D1DeviceContext.SetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(78)]
public void SetPrimitiveBlend(PrimitiveBlend primitiveBlend)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, PrimitiveBlend, void>)(lpVtbl[78]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), primitiveBlend);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetPrimitiveBlend" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(79)]
public PrimitiveBlend GetPrimitiveBlend()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, PrimitiveBlend>)(lpVtbl[79]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1DeviceContext.SetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(80)]
public void SetUnitMode(UnitMode unitMode)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, UnitMode, void>)(lpVtbl[80]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), unitMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetUnitMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(81)]
public UnitMode GetUnitMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, UnitMode>)(lpVtbl[81]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, Graphics.DirectWrite.GlyphRunDescription*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[82]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ID2D1Image*, System.Drawing.PointF*, Common.RectF*, InterpolationMode, Common.CompositeMode, void>)(lpVtbl[83]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
}
/// <inheritdoc cref="ID2D1DeviceContext.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(84)]
public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, System.Drawing.PointF* targetOffset)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GdiMetafile*, System.Drawing.PointF*, void>)(lpVtbl[84]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gdiMetafile, targetOffset);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ID2D1Bitmap*, Common.RectF*, float, InterpolationMode, Common.RectF*, Matrix4x4*, void>)(lpVtbl[85]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
/// <inheritdoc cref="ID2D1DeviceContext.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(86)]
public void PushLayer(LayerParameters1* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, LayerParameters1*, ID2D1Layer*, void>)(lpVtbl[86]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1DeviceContext.InvalidateEffectInputRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(87)]
public HResult InvalidateEffectInputRectangle(ID2D1Effect* effect, uint input, Common.RectF* inputRectangle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, uint, Common.RectF*, int>)(lpVtbl[87]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effect, input, inputRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangleCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(88)]
public HResult GetEffectInvalidRectangleCount(ID2D1Effect* effect, uint* rectangleCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, uint*, int>)(lpVtbl[88]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effect, rectangleCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.GetEffectInvalidRectangles" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(89)]
public HResult GetEffectInvalidRectangles(ID2D1Effect* effect, Common.RectF* rectangles, uint rectanglesCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Effect*, Common.RectF*, uint, int>)(lpVtbl[89]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), effect, rectangles, rectanglesCount);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ID2D1Effect*, Common.RectF*, EffectInputDescription*, Common.RectF*, uint, int>)(lpVtbl[90]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
}
/// <inheritdoc cref="ID2D1DeviceContext.FillOpacityMask" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(91)]
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[91]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), opacityMask, brush, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext1.CreateFilledGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(92)]
public HResult CreateFilledGeometryRealization(ID2D1Geometry* geometry, float flatteningTolerance, ID2D1GeometryRealization** geometryRealization)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Geometry*, float, ID2D1GeometryRealization**, int>)(lpVtbl[92]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, geometryRealization);
}
/// <inheritdoc cref="ID2D1DeviceContext1.CreateStrokedGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(93)]
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[93]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
}
/// <inheritdoc cref="ID2D1DeviceContext1.DrawGeometryRealization" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(94)]
public void DrawGeometryRealization(ID2D1GeometryRealization* geometryRealization, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GeometryRealization*, ID2D1Brush*, void>)(lpVtbl[94]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), geometryRealization, brush);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(95)]
public HResult CreateInk(InkPoint* startPoint, ID2D1Ink** ink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, InkPoint*, ID2D1Ink**, int>)(lpVtbl[95]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), startPoint, ink);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateInkStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(96)]
public HResult CreateInkStyle(InkStyleProperties* inkStyleProperties, ID2D1InkStyle** inkStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, InkStyleProperties*, ID2D1InkStyle**, int>)(lpVtbl[96]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), inkStyleProperties, inkStyle);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(97)]
public HResult CreateGradientMesh(GradientMeshPatch* patches, uint patchesCount, ID2D1GradientMesh** gradientMesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, GradientMeshPatch*, uint, ID2D1GradientMesh**, int>)(lpVtbl[97]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), patches, patchesCount, gradientMesh);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, Graphics.Imaging.IWICBitmapSource*, ImageSourceLoadingOptions, Common.AlphaMode, ID2D1ImageSourceFromWic**, int>)(lpVtbl[98]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), wicBitmapSource, loadingOptions, alphaMode, imageSource);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[99]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, Graphics.Dxgi.IDXGISurface**, uint, Graphics.Dxgi.Common.ColorSpaceType, ImageSourceFromDxgiOptions, ID2D1ImageSource**, int>)(lpVtbl[100]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), surfaces, surfaceCount, colorSpace, options, imageSource);
}
/// <inheritdoc cref="ID2D1DeviceContext2.GetGradientMeshWorldBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(101)]
public HResult GetGradientMeshWorldBounds(ID2D1GradientMesh* gradientMesh, Common.RectF* pBounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GradientMesh*, Common.RectF*, int>)(lpVtbl[101]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gradientMesh, pBounds);
}
/// <inheritdoc cref="ID2D1DeviceContext2.DrawInk" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(102)]
public void DrawInk(ID2D1Ink* ink, ID2D1Brush* brush, ID2D1InkStyle* inkStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1Ink*, ID2D1Brush*, ID2D1InkStyle*, void>)(lpVtbl[102]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), ink, brush, inkStyle);
}
/// <inheritdoc cref="ID2D1DeviceContext2.DrawGradientMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(103)]
public void DrawGradientMesh(ID2D1GradientMesh* gradientMesh)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GradientMesh*, void>)(lpVtbl[103]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gradientMesh);
}
/// <inheritdoc cref="ID2D1DeviceContext2.DrawGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(104)]
public void DrawGdiMetafile(ID2D1GdiMetafile* gdiMetafile, Common.RectF* destinationRectangle, Common.RectF* sourceRectangle)
{
((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1GdiMetafile*, Common.RectF*, Common.RectF*, void>)(lpVtbl[104]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), gdiMetafile, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="ID2D1DeviceContext2.CreateTransformedImageSource" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(105)]
public HResult CreateTransformedImageSource(ID2D1ImageSource* imageSource, TransformedImageSourceProperties* properties, ID2D1TransformedImageSource** transformedImageSource)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1ImageSource*, TransformedImageSourceProperties*, ID2D1TransformedImageSource**, int>)(lpVtbl[105]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), imageSource, properties, transformedImageSource);
}
/// <inheritdoc cref="ID2D1DeviceContext3.CreateSpriteBatch" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(106)]
public HResult CreateSpriteBatch(ID2D1SpriteBatch** spriteBatch)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DeviceContext4*, ID2D1SpriteBatch**, int>)(lpVtbl[106]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), spriteBatch);
}
/// <inheritdoc cref="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]<ID2D1DeviceContext4*, ID2D1SpriteBatch*, uint, uint, ID2D1Bitmap*, BitmapInterpolationMode, SpriteOptions, void>)(lpVtbl[107]))((ID2D1DeviceContext4*)Unsafe.AsPointer(ref this), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
}
/// <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);
}
}

1012
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext5.cs Normal file
View File

File diff suppressed because it is too large Load Diff

1020
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DeviceContext6.cs Normal file
View File

File diff suppressed because it is too large Load Diff

155
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DrawInfo.cs Normal file
View File

@@ -0,0 +1,155 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DrawTransform.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1TransformNode.GetInputCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public uint GetInputCount()
{
return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, uint>)(lpVtbl[3]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Transform.MapOutputRectToInputRects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, RawRect*, RawRect*, uint, int>)(lpVtbl[4]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
}
/// <inheritdoc cref="ID2D1Transform.MapInputRectsToOutputRect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
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[5]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
}
/// <inheritdoc cref="ID2D1Transform.MapInvalidRect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1DrawTransform*, uint, RawRect*, RawRect*, int>)(lpVtbl[6]))((ID2D1DrawTransform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
}
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DrawingStateBlock.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

139
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1DrawingStateBlock1.cs Normal file
View File

@@ -0,0 +1,139 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1DrawingStateBlock.GetDescription" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDescription(DrawingStateDescription* stateDescription)
{
((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, DrawingStateDescription*, void>)(lpVtbl[4]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), stateDescription);
}
/// <inheritdoc cref="ID2D1DrawingStateBlock.SetDescription" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetDescription(DrawingStateDescription* stateDescription)
{
((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, DrawingStateDescription*, void>)(lpVtbl[5]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), stateDescription);
}
/// <inheritdoc cref="ID2D1DrawingStateBlock.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[6]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1DrawingStateBlock.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1DrawingStateBlock1*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[7]))((ID2D1DrawingStateBlock1*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <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);
}
}

211
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Effect.cs Normal file
View File

@@ -0,0 +1,211 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 PropertyType GetType(uint index)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Effect*, uint, 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);
}
}

251
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1EffectContext.cs Normal file
View File

@@ -0,0 +1,251 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

259
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1EffectContext1.cs Normal file
View File

@@ -0,0 +1,259 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

275
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1EffectContext2.cs Normal file
View File

@@ -0,0 +1,275 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1EffectContext.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1EffectContext2*, float*, float*, void>)(lpVtbl[3]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, ID2D1Effect**, int>)(lpVtbl[4]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Graphics.Direct3D.FeatureLevel*, uint, Graphics.Direct3D.FeatureLevel*, int>)(lpVtbl[5]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, ID2D1Effect*, ID2D1TransformNode**, int>)(lpVtbl[6]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, uint, BlendDescription*, ID2D1BlendTransform**, int>)(lpVtbl[7]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, ExtendMode, ExtendMode, ID2D1BorderTransform**, int>)(lpVtbl[8]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, System.Drawing.Point*, ID2D1OffsetTransform**, int>)(lpVtbl[9]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, RawRect*, ID2D1BoundsAdjustmentTransform**, int>)(lpVtbl[10]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, byte*, uint, int>)(lpVtbl[11]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, byte*, uint, int>)(lpVtbl[12]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, byte*, uint, int>)(lpVtbl[13]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, Bool32>)(lpVtbl[14]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, ResourceTextureProperties*, byte*, uint*, uint, ID2D1ResourceTexture**, int>)(lpVtbl[15]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, ID2D1ResourceTexture**, int>)(lpVtbl[16]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, VertexBufferProperties*, Guid*, CustomVertexBufferProperties*, ID2D1VertexBuffer**, int>)(lpVtbl[17]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Guid*, ID2D1VertexBuffer**, int>)(lpVtbl[18]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, ColorSpace, byte*, uint, ID2D1ColorContext**, int>)(lpVtbl[19]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, ushort*, ID2D1ColorContext**, int>)(lpVtbl[20]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Graphics.Imaging.IWICColorContext*, ID2D1ColorContext**, int>)(lpVtbl[21]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, Feature, void*, uint, int>)(lpVtbl[22]))((ID2D1EffectContext2*)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]<ID2D1EffectContext2*, BufferPrecision, Bool32>)(lpVtbl[23]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), bufferPrecision);
}
/// <inheritdoc cref="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]<ID2D1EffectContext2*, BufferPrecision, uint*, byte*, uint, uint*, ID2D1LookupTable3D**, int>)(lpVtbl[24]))((ID2D1EffectContext2*)Unsafe.AsPointer(ref this), precision, extents, data, dataCount, strides, lookupTable);
}
/// <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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1EffectImpl.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

203
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1EllipseGeometry.cs Normal file
View File

@@ -0,0 +1,203 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
}
/// <inheritdoc cref="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]<ID2D1EllipseGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
/// <inheritdoc cref="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]<ID2D1EllipseGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
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[7]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
/// <inheritdoc cref="ID2D1Geometry.Simplify" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
}
/// <inheritdoc cref="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]<ID2D1EllipseGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Outline" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
{
return ((delegate* unmanaged[Stdcall]<ID2D1EllipseGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
}
/// <inheritdoc cref="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]<ID2D1EllipseGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
/// <inheritdoc cref="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]<ID2D1EllipseGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1EllipseGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
/// <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);
}
}

195
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory.cs Normal file
View File

@@ -0,0 +1,195 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

275
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory1.cs Normal file
View File

@@ -0,0 +1,275 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

283
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory2.cs Normal file
View File

@@ -0,0 +1,283 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Factory.ReloadSystemMetrics" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult ReloadSystemMetrics()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, int>)(lpVtbl[3]))((ID2D1Factory2*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDesktopDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Factory2*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory2*)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]<ID2D1Factory2*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory2*)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]<ID2D1Factory2*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory2*)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]<ID2D1Factory2*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory2*)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]<ID2D1Factory2*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory2*)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]<ID2D1Factory2*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory2*)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]<ID2D1Factory2*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory2*)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]<ID2D1Factory2*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory2*)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]<ID2D1Factory2*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory2*)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]<ID2D1Factory2*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory2*)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]<ID2D1Factory2*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory2*)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]<ID2D1Factory2*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory2*)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]<ID2D1Factory2*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
}
/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), pathGeometry);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), metafileStream, metafile);
}
/// <inheritdoc cref="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]<ID2D1Factory2*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="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]<ID2D1Factory2*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public HResult UnregisterEffect(Guid* classId)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), classId);
}
/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(25)]
public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
}
/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory2*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory2*)Unsafe.AsPointer(ref this), effectId, properties);
}
/// <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);
}
}

291
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory3.cs Normal file
View File

@@ -0,0 +1,291 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Factory.ReloadSystemMetrics" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult ReloadSystemMetrics()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, int>)(lpVtbl[3]))((ID2D1Factory3*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDesktopDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Factory3*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory3*)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]<ID2D1Factory3*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory3*)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]<ID2D1Factory3*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory3*)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]<ID2D1Factory3*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory3*)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]<ID2D1Factory3*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory3*)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]<ID2D1Factory3*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory3*)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]<ID2D1Factory3*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory3*)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]<ID2D1Factory3*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory3*)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]<ID2D1Factory3*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory3*)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]<ID2D1Factory3*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory3*)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]<ID2D1Factory3*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory3*)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]<ID2D1Factory3*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory3*)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]<ID2D1Factory3*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
}
/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), pathGeometry);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), metafileStream, metafile);
}
/// <inheritdoc cref="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]<ID2D1Factory3*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="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]<ID2D1Factory3*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public HResult UnregisterEffect(Guid* classId)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), classId);
}
/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(25)]
public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
}
/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), effectId, properties);
}
/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory3*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[27]))((ID2D1Factory3*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
}
/// <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);
}
}

299
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory4.cs Normal file
View File

@@ -0,0 +1,299 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Factory.ReloadSystemMetrics" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult ReloadSystemMetrics()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, int>)(lpVtbl[3]))((ID2D1Factory4*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDesktopDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Factory4*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory4*)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]<ID2D1Factory4*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory4*)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]<ID2D1Factory4*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory4*)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]<ID2D1Factory4*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory4*)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]<ID2D1Factory4*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory4*)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]<ID2D1Factory4*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory4*)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]<ID2D1Factory4*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory4*)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]<ID2D1Factory4*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory4*)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]<ID2D1Factory4*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory4*)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]<ID2D1Factory4*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory4*)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]<ID2D1Factory4*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory4*)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]<ID2D1Factory4*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory4*)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]<ID2D1Factory4*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
}
/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), pathGeometry);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), metafileStream, metafile);
}
/// <inheritdoc cref="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]<ID2D1Factory4*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="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]<ID2D1Factory4*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public HResult UnregisterEffect(Guid* classId)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), classId);
}
/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(25)]
public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
}
/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), effectId, properties);
}
/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[27]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
}
/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory4*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[28]))((ID2D1Factory4*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
}
/// <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);
}
}

307
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory5.cs Normal file
View File

@@ -0,0 +1,307 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Factory.ReloadSystemMetrics" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult ReloadSystemMetrics()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, int>)(lpVtbl[3]))((ID2D1Factory5*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDesktopDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Factory5*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory5*)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]<ID2D1Factory5*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory5*)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]<ID2D1Factory5*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory5*)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]<ID2D1Factory5*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory5*)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]<ID2D1Factory5*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory5*)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]<ID2D1Factory5*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory5*)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]<ID2D1Factory5*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory5*)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]<ID2D1Factory5*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory5*)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]<ID2D1Factory5*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory5*)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]<ID2D1Factory5*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory5*)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]<ID2D1Factory5*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory5*)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]<ID2D1Factory5*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory5*)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]<ID2D1Factory5*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
}
/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), pathGeometry);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), metafileStream, metafile);
}
/// <inheritdoc cref="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]<ID2D1Factory5*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="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]<ID2D1Factory5*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public HResult UnregisterEffect(Guid* classId)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), classId);
}
/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(25)]
public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
}
/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), effectId, properties);
}
/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[27]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
}
/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[28]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
}
/// <inheritdoc cref="ID2D1Factory4.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(29)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory5*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[29]))((ID2D1Factory5*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
}
/// <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);
}
}

315
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory6.cs Normal file
View File

@@ -0,0 +1,315 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Factory.ReloadSystemMetrics" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult ReloadSystemMetrics()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, int>)(lpVtbl[3]))((ID2D1Factory6*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDesktopDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Factory6*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory6*)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]<ID2D1Factory6*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory6*)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]<ID2D1Factory6*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory6*)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]<ID2D1Factory6*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory6*)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]<ID2D1Factory6*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory6*)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]<ID2D1Factory6*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory6*)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]<ID2D1Factory6*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory6*)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]<ID2D1Factory6*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory6*)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]<ID2D1Factory6*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory6*)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]<ID2D1Factory6*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory6*)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]<ID2D1Factory6*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory6*)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]<ID2D1Factory6*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory6*)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]<ID2D1Factory6*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
}
/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), pathGeometry);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), metafileStream, metafile);
}
/// <inheritdoc cref="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]<ID2D1Factory6*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="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]<ID2D1Factory6*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public HResult UnregisterEffect(Guid* classId)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), classId);
}
/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(25)]
public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
}
/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), effectId, properties);
}
/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[27]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
}
/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[28]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
}
/// <inheritdoc cref="ID2D1Factory4.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(29)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[29]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
}
/// <inheritdoc cref="ID2D1Factory5.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device4** d2dDevice4)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory6*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device4**, int>)(lpVtbl[30]))((ID2D1Factory6*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice4);
}
/// <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);
}
}

323
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Factory7.cs Normal file
View File

@@ -0,0 +1,323 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Factory.ReloadSystemMetrics" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public HResult ReloadSystemMetrics()
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, int>)(lpVtbl[3]))((ID2D1Factory7*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Factory.GetDesktopDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void GetDesktopDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1Factory7*, float*, float*, void>)(lpVtbl[4]))((ID2D1Factory7*)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]<ID2D1Factory7*, Common.RectF*, ID2D1RectangleGeometry**, int>)(lpVtbl[5]))((ID2D1Factory7*)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]<ID2D1Factory7*, RoundedRect*, ID2D1RoundedRectangleGeometry**, int>)(lpVtbl[6]))((ID2D1Factory7*)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]<ID2D1Factory7*, Ellipse*, ID2D1EllipseGeometry**, int>)(lpVtbl[7]))((ID2D1Factory7*)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]<ID2D1Factory7*, Common.FillMode, ID2D1Geometry**, uint, ID2D1GeometryGroup**, int>)(lpVtbl[8]))((ID2D1Factory7*)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]<ID2D1Factory7*, ID2D1Geometry*, Matrix3x2*, ID2D1TransformedGeometry**, int>)(lpVtbl[9]))((ID2D1Factory7*)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]<ID2D1Factory7*, ID2D1PathGeometry**, int>)(lpVtbl[10]))((ID2D1Factory7*)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]<ID2D1Factory7*, StrokeStyleProperties*, float*, uint, ID2D1StrokeStyle**, int>)(lpVtbl[11]))((ID2D1Factory7*)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]<ID2D1Factory7*, DrawingStateDescription*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock**, int>)(lpVtbl[12]))((ID2D1Factory7*)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]<ID2D1Factory7*, Graphics.Imaging.IWICBitmap*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[13]))((ID2D1Factory7*)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]<ID2D1Factory7*, RenderTargetProperties*, HwndRenderTargetProperties*, ID2D1HwndRenderTarget**, int>)(lpVtbl[14]))((ID2D1Factory7*)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]<ID2D1Factory7*, Graphics.Dxgi.IDXGISurface*, RenderTargetProperties*, ID2D1RenderTarget**, int>)(lpVtbl[15]))((ID2D1Factory7*)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]<ID2D1Factory7*, RenderTargetProperties*, ID2D1DCRenderTarget**, int>)(lpVtbl[16]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), renderTargetProperties, dcRenderTarget);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device** d2dDevice)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device**, int>)(lpVtbl[17]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice);
}
/// <inheritdoc cref="ID2D1Factory1.CreateStrokeStyle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult CreateStrokeStyle(StrokeStyleProperties1* strokeStyleProperties, float* dashes, uint dashesCount, ID2D1StrokeStyle1** strokeStyle)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, StrokeStyleProperties1*, float*, uint, ID2D1StrokeStyle1**, int>)(lpVtbl[18]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
/// <inheritdoc cref="ID2D1Factory1.CreatePathGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult CreatePathGeometry(ID2D1PathGeometry1** pathGeometry)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, ID2D1PathGeometry1**, int>)(lpVtbl[19]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), pathGeometry);
}
/// <inheritdoc cref="ID2D1Factory1.CreateDrawingStateBlock" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult CreateDrawingStateBlock(DrawingStateDescription1* drawingStateDescription, Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams, ID2D1DrawingStateBlock1** drawingStateBlock)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, DrawingStateDescription1*, Graphics.DirectWrite.IDWriteRenderingParams*, ID2D1DrawingStateBlock1**, int>)(lpVtbl[20]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
/// <inheritdoc cref="ID2D1Factory1.CreateGdiMetafile" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public HResult CreateGdiMetafile(Com.IStream* metafileStream, ID2D1GdiMetafile** metafile)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Com.IStream*, ID2D1GdiMetafile**, int>)(lpVtbl[21]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), metafileStream, metafile);
}
/// <inheritdoc cref="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]<ID2D1Factory7*, Guid*, Com.IStream*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[22]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="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]<ID2D1Factory7*, Guid*, ushort*, PropertyBinding*, uint, delegate* unmanaged[Stdcall]<void*, void>, int>)(lpVtbl[23]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
/// <inheritdoc cref="ID2D1Factory1.UnregisterEffect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public HResult UnregisterEffect(Guid* classId)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, int>)(lpVtbl[24]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), classId);
}
/// <inheritdoc cref="ID2D1Factory1.GetRegisteredEffects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(25)]
public HResult GetRegisteredEffects(Guid* effects, uint effectsCount, uint* effectsReturned, uint* effectsRegistered)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, uint, uint*, uint*, int>)(lpVtbl[25]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), effects, effectsCount, effectsReturned, effectsRegistered);
}
/// <inheritdoc cref="ID2D1Factory1.GetEffectProperties" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(26)]
public HResult GetEffectProperties(Guid* effectId, ID2D1Properties** properties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Guid*, ID2D1Properties**, int>)(lpVtbl[26]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), effectId, properties);
}
/// <inheritdoc cref="ID2D1Factory2.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(27)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device1** d2dDevice1)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device1**, int>)(lpVtbl[27]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice1);
}
/// <inheritdoc cref="ID2D1Factory3.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(28)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device2** d2dDevice2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device2**, int>)(lpVtbl[28]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice2);
}
/// <inheritdoc cref="ID2D1Factory4.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(29)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device3** d2dDevice3)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device3**, int>)(lpVtbl[29]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice3);
}
/// <inheritdoc cref="ID2D1Factory5.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device4** d2dDevice4)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device4**, int>)(lpVtbl[30]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice4);
}
/// <inheritdoc cref="ID2D1Factory6.CreateDevice" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public HResult CreateDevice(Graphics.Dxgi.IDXGIDevice* dxgiDevice, ID2D1Device5** d2dDevice5)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Factory7*, Graphics.Dxgi.IDXGIDevice*, ID2D1Device5**, int>)(lpVtbl[31]))((ID2D1Factory7*)Unsafe.AsPointer(ref this), dxgiDevice, d2dDevice5);
}
/// <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);
}
}

99
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GdiInteropRenderTarget.cs Normal file
View File

@@ -0,0 +1,99 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GdiMetafile.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GdiMetafile1.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1GdiMetafile.Stream" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult Stream(ID2D1GdiMetafileSink* sink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, ID2D1GdiMetafileSink*, int>)(lpVtbl[4]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), sink);
}
/// <inheritdoc cref="ID2D1GdiMetafile.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult GetBounds(Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GdiMetafile1*, Common.RectF*, int>)(lpVtbl[5]))((ID2D1GdiMetafile1*)Unsafe.AsPointer(ref this), bounds);
}
/// <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);
}
}

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GdiMetafileSink.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

99
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GdiMetafileSink1.cs Normal file
View File

@@ -0,0 +1,99 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

195
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Geometry.cs Normal file
View File

@@ -0,0 +1,195 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

219
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GeometryGroup.cs Normal file
View File

@@ -0,0 +1,219 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, bounds);
}
/// <inheritdoc cref="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]<ID2D1GeometryGroup*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
/// <inheritdoc cref="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]<ID2D1GeometryGroup*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
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[7]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
/// <inheritdoc cref="ID2D1Geometry.Simplify" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
}
/// <inheritdoc cref="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]<ID2D1GeometryGroup*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Outline" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
}
/// <inheritdoc cref="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]<ID2D1GeometryGroup*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
/// <inheritdoc cref="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]<ID2D1GeometryGroup*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1GeometryGroup*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1GeometryGroup::GetFillMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public Common.FillMode GetFillMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GeometryGroup*, 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);
}
}

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GeometryRealization.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

153
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GeometrySink.cs Normal file
View File

@@ -0,0 +1,153 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GradientMesh.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GradientStopCollection.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 Gamma GetColorInterpolationGamma()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, Gamma>)(lpVtbl[6]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection::GetExtendMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public ExtendMode GetExtendMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection*, ExtendMode>)(lpVtbl[7]))((ID2D1GradientStopCollection*)Unsafe.AsPointer(ref this));
}
}

163
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1GradientStopCollection1.cs Normal file
View File

@@ -0,0 +1,163 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1GradientStopCollection.GetGradientStopCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public uint GetGradientStopCount()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, uint>)(lpVtbl[4]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1GradientStopCollection.GetGradientStops" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void GetGradientStops(GradientStop* gradientStops, uint gradientStopsCount)
{
((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, GradientStop*, uint, void>)(lpVtbl[5]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount);
}
/// <inheritdoc cref="ID2D1GradientStopCollection.GetColorInterpolationGamma" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public Gamma GetColorInterpolationGamma()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, Gamma>)(lpVtbl[6]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1GradientStopCollection.GetExtendMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public ExtendMode GetExtendMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, ExtendMode>)(lpVtbl[7]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
/// <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 ColorSpace GetPreInterpolationSpace()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, ColorSpace>)(lpVtbl[9]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetPostInterpolationSpace"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public ColorSpace GetPostInterpolationSpace()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, ColorSpace>)(lpVtbl[10]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetBufferPrecision"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public BufferPrecision GetBufferPrecision()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, BufferPrecision>)(lpVtbl[11]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1GradientStopCollection1::GetColorInterpolationMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public ColorInterpolationMode GetColorInterpolationMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1GradientStopCollection1*, ColorInterpolationMode>)(lpVtbl[12]))((ID2D1GradientStopCollection1*)Unsafe.AsPointer(ref this));
}
}

540
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1HwndRenderTarget.cs Normal file
View File

@@ -0,0 +1,540 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult CreateBitmap(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.Size, void*, uint, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[4]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), size, srcData, pitch, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapFromWicBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult CreateBitmapFromWicBitmap(Graphics.Imaging.IWICBitmapSource* wicBitmapSource, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.Imaging.IWICBitmapSource*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[5]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), wicBitmapSource, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSharedBitmap" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult CreateSharedBitmap(Guid* riid, void* data, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Guid*, void*, BitmapProperties*, ID2D1Bitmap**, int>)(lpVtbl[6]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), riid, data, bitmapProperties, bitmap);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateBitmapBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public HResult CreateBitmapBrush(ID2D1Bitmap* bitmap, BitmapBrushProperties* bitmapBrushProperties, BrushProperties* brushProperties, ID2D1BitmapBrush** bitmapBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Bitmap*, BitmapBrushProperties*, BrushProperties*, ID2D1BitmapBrush**, int>)(lpVtbl[7]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateSolidColorBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CreateSolidColorBrush(Common.ColorF* color, BrushProperties* brushProperties, ID2D1SolidColorBrush** solidColorBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.ColorF*, BrushProperties*, ID2D1SolidColorBrush**, int>)(lpVtbl[8]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), color, brushProperties, solidColorBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateGradientStopCollection" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
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[9]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLinearGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult CreateLinearGradientBrush(LinearGradientBrushProperties* linearGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1LinearGradientBrush** linearGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, LinearGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1LinearGradientBrush**, int>)(lpVtbl[10]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateRadialGradientBrush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public HResult CreateRadialGradientBrush(RadialGradientBrushProperties* radialGradientBrushProperties, BrushProperties* brushProperties, ID2D1GradientStopCollection* gradientStopCollection, ID2D1RadialGradientBrush** radialGradientBrush)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RadialGradientBrushProperties*, BrushProperties*, ID2D1GradientStopCollection*, ID2D1RadialGradientBrush**, int>)(lpVtbl[11]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateCompatibleRenderTarget" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult CreateCompatibleRenderTarget(System.Drawing.SizeF* desiredSize, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.SizeF*, System.Drawing.Size*, Common.PixelFormat*, CompatibleRenderTargetOptions, ID2D1BitmapRenderTarget**, int>)(lpVtbl[12]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult CreateLayer(System.Drawing.SizeF* size, ID2D1Layer** layer)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.SizeF*, ID2D1Layer**, int>)(lpVtbl[13]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), size, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.CreateMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult CreateMesh(ID2D1Mesh** mesh)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Mesh**, int>)(lpVtbl[14]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), mesh);
}
/// <inheritdoc cref="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]<ID2D1HwndRenderTarget*, System.Drawing.PointF*, System.Drawing.PointF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[15]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), point0, point1, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public void DrawRectangle(Common.RectF* rect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.RectF*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[16]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), rect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public void FillRectangle(Common.RectF* rect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.RectF*, ID2D1Brush*, void>)(lpVtbl[17]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), rect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public void DrawRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RoundedRect*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[18]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillRoundedRectangle" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public void FillRoundedRectangle(RoundedRect* roundedRect, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RoundedRect*, ID2D1Brush*, void>)(lpVtbl[19]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), roundedRect, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public void DrawEllipse(Ellipse* ellipse, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Ellipse*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[20]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillEllipse" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(21)]
public void FillEllipse(Ellipse* ellipse, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Ellipse*, ID2D1Brush*, void>)(lpVtbl[21]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), ellipse, brush);
}
/// <inheritdoc cref="ID2D1RenderTarget.DrawGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(22)]
public void DrawGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, float strokeWidth, ID2D1StrokeStyle* strokeStyle)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Geometry*, ID2D1Brush*, float, ID2D1StrokeStyle*, void>)(lpVtbl[22]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, strokeWidth, strokeStyle);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(23)]
public void FillGeometry(ID2D1Geometry* geometry, ID2D1Brush* brush, ID2D1Brush* opacityBrush)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Geometry*, ID2D1Brush*, ID2D1Brush*, void>)(lpVtbl[23]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), geometry, brush, opacityBrush);
}
/// <inheritdoc cref="ID2D1RenderTarget.FillMesh" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(24)]
public void FillMesh(ID2D1Mesh* mesh, ID2D1Brush* brush)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1Mesh*, ID2D1Brush*, void>)(lpVtbl[24]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), mesh, brush);
}
/// <inheritdoc cref="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]<ID2D1HwndRenderTarget*, ID2D1Bitmap*, ID2D1Brush*, OpacityMaskContent, Common.RectF*, Common.RectF*, void>)(lpVtbl[25]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1HwndRenderTarget*, ID2D1Bitmap*, Common.RectF*, float, BitmapInterpolationMode, Common.RectF*, void>)(lpVtbl[26]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
/// <inheritdoc cref="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]<ID2D1HwndRenderTarget*, ushort*, uint, Graphics.DirectWrite.IDWriteTextFormat*, Common.RectF*, ID2D1Brush*, DrawTextOptions, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[27]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
/// <inheritdoc cref="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]<ID2D1HwndRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.IDWriteTextLayout*, ID2D1Brush*, DrawTextOptions, void>)(lpVtbl[28]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), origin, textLayout, defaultFillBrush, options);
}
/// <inheritdoc cref="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]<ID2D1HwndRenderTarget*, System.Drawing.PointF*, Graphics.DirectWrite.GlyphRun*, ID2D1Brush*, Graphics.DirectWrite.MeasuringMode, void>)(lpVtbl[29]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(30)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Matrix3x2*, void>)(lpVtbl[30]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(31)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Matrix3x2**, void>)(lpVtbl[31]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(32)]
public void SetAntialiasMode(AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, AntialiasMode, void>)(lpVtbl[32]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(33)]
public AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, AntialiasMode>)(lpVtbl[33]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(34)]
public void SetTextAntialiasMode(TextAntialiasMode textAntialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, TextAntialiasMode, void>)(lpVtbl[34]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), textAntialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextAntialiasMode" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(35)]
public TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, TextAntialiasMode>)(lpVtbl[35]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(36)]
public void SetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams* textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams*, void>)(lpVtbl[36]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTextRenderingParams" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(37)]
public void GetTextRenderingParams(Graphics.DirectWrite.IDWriteRenderingParams** textRenderingParams)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Graphics.DirectWrite.IDWriteRenderingParams**, void>)(lpVtbl[37]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), textRenderingParams);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(38)]
public void SetTags(ulong tag1, ulong tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong, ulong, void>)(lpVtbl[38]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetTags" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(39)]
public void GetTags(ulong* tag1, ulong* tag2)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong*, ulong*, void>)(lpVtbl[39]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(40)]
public void PushLayer(LayerParameters* layerParameters, ID2D1Layer* layer)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, LayerParameters*, ID2D1Layer*, void>)(lpVtbl[40]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), layerParameters, layer);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopLayer" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(41)]
public void PopLayer()
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, void>)(lpVtbl[41]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Flush" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(42)]
public HResult Flush(ulong* tag1, ulong* tag2)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong*, ulong*, int>)(lpVtbl[42]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.SaveDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(43)]
public void SaveDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[43]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.RestoreDrawingState" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(44)]
public void RestoreDrawingState(ID2D1DrawingStateBlock* drawingStateBlock)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ID2D1DrawingStateBlock*, void>)(lpVtbl[44]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), drawingStateBlock);
}
/// <inheritdoc cref="ID2D1RenderTarget.PushAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(45)]
public void PushAxisAlignedClip(Common.RectF* clipRect, AntialiasMode antialiasMode)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.RectF*, AntialiasMode, void>)(lpVtbl[45]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), clipRect, antialiasMode);
}
/// <inheritdoc cref="ID2D1RenderTarget.PopAxisAlignedClip" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(46)]
public void PopAxisAlignedClip()
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, void>)(lpVtbl[46]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.Clear" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(47)]
public void Clear(Common.ColorF* clearColor)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.ColorF*, void>)(lpVtbl[47]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), clearColor);
}
/// <inheritdoc cref="ID2D1RenderTarget.BeginDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(48)]
public void BeginDraw()
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, void>)(lpVtbl[48]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.EndDraw" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(49)]
public HResult EndDraw(ulong* tag1 = null, ulong* tag2 = null)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, ulong*, ulong*, int>)(lpVtbl[49]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), tag1, tag2);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelFormat" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(50)]
public Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), &result);
}
/// <inheritdoc cref="ID2D1RenderTarget.SetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(51)]
public void SetDpi(float dpiX, float dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, float, float, void>)(lpVtbl[51]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetDpi" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(52)]
public void GetDpi(float* dpiX, float* dpiY)
{
((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, float*, float*, void>)(lpVtbl[52]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), dpiX, dpiY);
}
/// <inheritdoc cref="ID2D1RenderTarget.GetSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(53)]
public System.Drawing.SizeF GetSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.SizeF>)(lpVtbl[53]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetPixelSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(54)]
public System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.Size>)(lpVtbl[54]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.GetMaximumBitmapSize" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(55)]
public uint GetMaximumBitmapSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, uint>)(lpVtbl[55]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1RenderTarget.IsSupported" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(56)]
public Bool32 IsSupported(RenderTargetProperties* renderTargetProperties)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, RenderTargetProperties*, Bool32>)(lpVtbl[56]))((ID2D1HwndRenderTarget*)Unsafe.AsPointer(ref this), renderTargetProperties);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1HwndRenderTarget::CheckWindowState"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(57)]
public WindowState CheckWindowState()
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, 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(System.Drawing.Size* pixelSize)
{
return ((delegate* unmanaged[Stdcall]<ID2D1HwndRenderTarget*, System.Drawing.Size*, 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));
}
}

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Image.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

203
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ImageBrush.cs Normal file
View File

@@ -0,0 +1,203 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetOpacity(float opacity)
{
((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, float, void>)(lpVtbl[4]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), opacity);
}
/// <inheritdoc cref="ID2D1Brush.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public float GetOpacity()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, float>)(lpVtbl[6]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Brush.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <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 ExtendMode GetExtendModeX()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ExtendMode>)(lpVtbl[14]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetExtendModeY"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(15)]
public ExtendMode GetExtendModeY()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, ExtendMode>)(lpVtbl[15]))((ID2D1ImageBrush*)Unsafe.AsPointer(ref this));
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1ImageBrush::GetInterpolationMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(16)]
public InterpolationMode GetInterpolationMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ImageBrush*, 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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ImageSource.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

131
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ImageSourceFromWic.cs Normal file
View File

@@ -0,0 +1,131 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1ImageSource.OfferResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult OfferResources()
{
return ((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, int>)(lpVtbl[4]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1ImageSource.TryReclaimResources" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public HResult TryReclaimResources(Bool32* resourcesDiscarded)
{
return ((delegate* unmanaged[Stdcall]<ID2D1ImageSourceFromWic*, Bool32*, int>)(lpVtbl[5]))((ID2D1ImageSourceFromWic*)Unsafe.AsPointer(ref this), resourcesDiscarded);
}
/// <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);
}
}

172
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Ink.cs Normal file
View File

@@ -0,0 +1,172 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 InkPoint GetStartPoint()
{
InkPoint result;
return *((delegate* unmanaged[Stdcall]<ID2D1Ink*, InkPoint*, InkPoint*>)(lpVtbl[5]))((ID2D1Ink*)Unsafe.AsPointer(ref this), &result);
}
/// <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);
}
}

123
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1InkStyle.cs Normal file
View File

@@ -0,0 +1,123 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 InkNibShape GetNibShape()
{
return ((delegate* unmanaged[Stdcall]<ID2D1InkStyle*, InkNibShape>)(lpVtbl[7]))((ID2D1InkStyle*)Unsafe.AsPointer(ref this));
}
}

99
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Layer.cs Normal file
View File

@@ -0,0 +1,99 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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));
}
}

165
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1LinearGradientBrush.cs Normal file
View File

@@ -0,0 +1,165 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetOpacity(float opacity)
{
((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, float, void>)(lpVtbl[4]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), opacity);
}
/// <inheritdoc cref="ID2D1Brush.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public float GetOpacity()
{
return ((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, float>)(lpVtbl[6]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Brush.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <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()
{
System.Drawing.PointF result;
return *((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, System.Drawing.PointF*, System.Drawing.PointF*>)(lpVtbl[10]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), &result);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1LinearGradientBrush::GetEndPoint"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(11)]
public System.Drawing.PointF GetEndPoint()
{
System.Drawing.PointF result;
return *((delegate* unmanaged[Stdcall]<ID2D1LinearGradientBrush*, System.Drawing.PointF*, System.Drawing.PointF*>)(lpVtbl[11]))((ID2D1LinearGradientBrush*)Unsafe.AsPointer(ref this), &result);
}
/// <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);
}
}

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1LookupTable3D.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

99
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Mesh.cs Normal file
View File

@@ -0,0 +1,99 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

107
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Multithread.cs Normal file
View File

@@ -0,0 +1,107 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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));
}
}

108
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1OffsetTransform.cs Normal file
View File

@@ -0,0 +1,108 @@
// ------------------------------------------------------------------------------
// <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;
/// <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()
{
System.Drawing.Point result;
return *((delegate* unmanaged[Stdcall]<ID2D1OffsetTransform*, System.Drawing.Point*, System.Drawing.Point*>)(lpVtbl[5]))((ID2D1OffsetTransform*)Unsafe.AsPointer(ref this), &result);
}
}

227
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1PathGeometry.cs Normal file
View File

@@ -0,0 +1,227 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
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[7]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
/// <inheritdoc cref="ID2D1Geometry.Simplify" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Outline" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1PathGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
/// <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);
}
}

235
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1PathGeometry1.cs Normal file
View File

@@ -0,0 +1,235 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, bounds);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry1*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry1*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
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[7]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
/// <inheritdoc cref="ID2D1Geometry.Simplify" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry1*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Outline" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry1*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
/// <inheritdoc cref="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]<ID2D1PathGeometry1*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1PathGeometry.Open" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(17)]
public HResult Open(ID2D1GeometrySink** geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1GeometrySink**, int>)(lpVtbl[17]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), geometrySink);
}
/// <inheritdoc cref="ID2D1PathGeometry.Stream" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(18)]
public HResult Stream(ID2D1GeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, ID2D1GeometrySink*, int>)(lpVtbl[18]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), geometrySink);
}
/// <inheritdoc cref="ID2D1PathGeometry.GetSegmentCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(19)]
public HResult GetSegmentCount(uint* count)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, uint*, int>)(lpVtbl[19]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), count);
}
/// <inheritdoc cref="ID2D1PathGeometry.GetFigureCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(20)]
public HResult GetFigureCount(uint* count)
{
return ((delegate* unmanaged[Stdcall]<ID2D1PathGeometry1*, uint*, int>)(lpVtbl[20]))((ID2D1PathGeometry1*)Unsafe.AsPointer(ref this), count);
}
/// <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);
}
}

99
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1PrintControl.cs Normal file
View File

@@ -0,0 +1,99 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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));
}
}

171
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Properties.cs Normal file
View File

@@ -0,0 +1,171 @@
// ------------------------------------------------------------------------------
// <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;
/// <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 PropertyType GetType(uint index)
{
return ((delegate* unmanaged[Stdcall]<ID2D1Properties*, uint, 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);
}
}

197
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1RadialGradientBrush.cs Normal file
View File

@@ -0,0 +1,197 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetOpacity(float opacity)
{
((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float, void>)(lpVtbl[4]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), opacity);
}
/// <inheritdoc cref="ID2D1Brush.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public float GetOpacity()
{
return ((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, float>)(lpVtbl[6]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Brush.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <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()
{
System.Drawing.PointF result;
return *((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, System.Drawing.PointF*, System.Drawing.PointF*>)(lpVtbl[12]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), &result);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1RadialGradientBrush::GetGradientOriginOffset"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public System.Drawing.PointF GetGradientOriginOffset()
{
System.Drawing.PointF result;
return *((delegate* unmanaged[Stdcall]<ID2D1RadialGradientBrush*, System.Drawing.PointF*, System.Drawing.PointF*>)(lpVtbl[13]))((ID2D1RadialGradientBrush*)Unsafe.AsPointer(ref this), &result);
}
/// <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);
}
}

203
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1RectangleGeometry.cs Normal file
View File

@@ -0,0 +1,203 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
}
/// <inheritdoc cref="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]<ID2D1RectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
/// <inheritdoc cref="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]<ID2D1RectangleGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
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[7]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
/// <inheritdoc cref="ID2D1Geometry.Simplify" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
}
/// <inheritdoc cref="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]<ID2D1RectangleGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Outline" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
}
/// <inheritdoc cref="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]<ID2D1RectangleGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
/// <inheritdoc cref="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]<ID2D1RectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1RectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
/// <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);
}
}

115
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1RenderInfo.cs Normal file
View File

@@ -0,0 +1,115 @@
// ------------------------------------------------------------------------------
// <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;
/// <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);
}
}

516
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1RenderTarget.cs Normal file
View File

@@ -0,0 +1,516 @@
// ------------------------------------------------------------------------------
// <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;
/// <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(System.Drawing.Size size, void* srcData, uint pitch, BitmapProperties* bitmapProperties, ID2D1Bitmap** bitmap)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.Size, 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, System.Drawing.Size* desiredPixelSize, Common.PixelFormat* desiredFormat, CompatibleRenderTargetOptions options, ID2D1BitmapRenderTarget** bitmapRenderTarget)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.SizeF*, System.Drawing.Size*, 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 AntialiasMode GetAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, 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 TextAntialiasMode GetTextAntialiasMode()
{
return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, 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 = null, ulong* tag2 = null)
{
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 Common.PixelFormat GetPixelFormat()
{
Common.PixelFormat result;
return *((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, Common.PixelFormat*, Common.PixelFormat*>)(lpVtbl[50]))((ID2D1RenderTarget*)Unsafe.AsPointer(ref this), &result);
}
/// <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 System.Drawing.Size GetPixelSize()
{
return ((delegate* unmanaged[Stdcall]<ID2D1RenderTarget*, System.Drawing.Size>)(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);
}
}

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1Resource.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

91
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1ResourceTexture.cs Normal file
View File

@@ -0,0 +1,91 @@
// ------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------
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;
/// <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);
}
}

203
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1RoundedRectangleGeometry.cs Normal file
View File

@@ -0,0 +1,203 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Geometry.GetBounds" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult GetBounds(Matrix3x2* worldTransform, Common.RectF* bounds)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, Common.RectF*, int>)(lpVtbl[4]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, bounds);
}
/// <inheritdoc cref="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]<ID2D1RoundedRectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.RectF*, int>)(lpVtbl[5]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
/// <inheritdoc cref="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]<ID2D1RoundedRectangleGeometry*, System.Drawing.PointF*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Bool32*, int>)(lpVtbl[6]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.FillContainsPoint" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
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[7]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), point, worldTransform, flatteningTolerance, contains);
}
/// <inheritdoc cref="ID2D1Geometry.CompareWithGeometry" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public HResult CompareWithGeometry(ID2D1Geometry* inputGeometry, Matrix3x2* inputGeometryTransform, float flatteningTolerance, GeometryRelation* relation)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, ID2D1Geometry*, Matrix3x2*, float, GeometryRelation*, int>)(lpVtbl[8]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
/// <inheritdoc cref="ID2D1Geometry.Simplify" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Simplify(GeometrySimplificationOption simplificationOption, Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, GeometrySimplificationOption, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Tessellate" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(10)]
public HResult Tessellate(Matrix3x2* worldTransform, float flatteningTolerance, ID2D1TessellationSink* tessellationSink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, ID2D1TessellationSink*, int>)(lpVtbl[10]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, tessellationSink);
}
/// <inheritdoc cref="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]<ID2D1RoundedRectangleGeometry*, ID2D1Geometry*, CombineMode, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[11]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.Outline" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(12)]
public HResult Outline(Matrix3x2* worldTransform, float flatteningTolerance, Common.ID2D1SimplifiedGeometrySink* geometrySink)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[12]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, geometrySink);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeArea" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(13)]
public HResult ComputeArea(Matrix3x2* worldTransform, float flatteningTolerance, float* area)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[13]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, area);
}
/// <inheritdoc cref="ID2D1Geometry.ComputeLength" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(14)]
public HResult ComputeLength(Matrix3x2* worldTransform, float flatteningTolerance, float* length)
{
return ((delegate* unmanaged[Stdcall]<ID2D1RoundedRectangleGeometry*, Matrix3x2*, float, float*, int>)(lpVtbl[14]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), worldTransform, flatteningTolerance, length);
}
/// <inheritdoc cref="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]<ID2D1RoundedRectangleGeometry*, float, Matrix3x2*, float, System.Drawing.PointF**, System.Drawing.PointF**, int>)(lpVtbl[15]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
/// <inheritdoc cref="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]<ID2D1RoundedRectangleGeometry*, float, ID2D1StrokeStyle*, Matrix3x2*, float, Common.ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[16]))((ID2D1RoundedRectangleGeometry*)Unsafe.AsPointer(ref this), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
/// <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);
}
}

139
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1SimplifiedGeometrySink.cs Normal file
View File

@@ -0,0 +1,139 @@
// ------------------------------------------------------------------------------
// <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.Common;
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink"]/*' />
/// <unmanaged>ID2D1SimplifiedGeometrySink</unmanaged>
[Guid("2cd9069e-12e2-11dc-9fed-001143a055f9")]
[NativeTypeName("struct ID2D1SimplifiedGeometrySink : IUnknown")]
[NativeInheritance("IUnknown")]
public unsafe partial struct ID2D1SimplifiedGeometrySink
{
public static ref readonly Guid IID_ID2D1SimplifiedGeometrySink
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
ReadOnlySpan<byte> data = new byte[] {
0x9E, 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_ID2D1SimplifiedGeometrySink));
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="ID2D1SimplifiedGeometrySink::SetFillMode"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void SetFillMode(FillMode fillMode)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, FillMode, void>)(lpVtbl[3]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), fillMode);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::SetSegmentFlags"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetSegmentFlags(PathSegment vertexFlags)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, PathSegment, void>)(lpVtbl[4]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), vertexFlags);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::BeginFigure"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void BeginFigure(System.Drawing.PointF* startPoint, FigureBegin figureBegin)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, System.Drawing.PointF*, FigureBegin, void>)(lpVtbl[5]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), startPoint, figureBegin);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::AddLines"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public void AddLines(System.Drawing.PointF** points, uint pointsCount)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, System.Drawing.PointF**, uint, void>)(lpVtbl[6]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), points, pointsCount);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::AddBeziers"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void AddBeziers(BezierSegment* beziers, uint beziersCount)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, BezierSegment*, uint, void>)(lpVtbl[7]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), beziers, beziersCount);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::EndFigure"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(8)]
public void EndFigure(FigureEnd figureEnd)
{
((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, FigureEnd, void>)(lpVtbl[8]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), figureEnd);
}
/// <include file='../../Direct2D.xml' path='doc/member[@name="ID2D1SimplifiedGeometrySink::Close"]/*' />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(9)]
public HResult Close()
{
return ((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this));
}
}

140
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1SolidColorBrush.cs Normal file
View File

@@ -0,0 +1,140 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1Resource.GetFactory" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public void GetFactory(ID2D1Factory** factory)
{
((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, ID2D1Factory**, void>)(lpVtbl[3]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), factory);
}
/// <inheritdoc cref="ID2D1Brush.SetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public void SetOpacity(float opacity)
{
((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, float, void>)(lpVtbl[4]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), opacity);
}
/// <inheritdoc cref="ID2D1Brush.SetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
public void SetTransform(Matrix3x2* transform)
{
((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Matrix3x2*, void>)(lpVtbl[5]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <inheritdoc cref="ID2D1Brush.GetOpacity" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public float GetOpacity()
{
return ((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, float>)(lpVtbl[6]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Brush.GetTransform" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(7)]
public void GetTransform(Matrix3x2** transform)
{
((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Matrix3x2**, void>)(lpVtbl[7]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), transform);
}
/// <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 Common.ColorF GetColor()
{
Common.ColorF result;
return *((delegate* unmanaged[Stdcall]<ID2D1SolidColorBrush*, Common.ColorF*, Common.ColorF*>)(lpVtbl[9]))((ID2D1SolidColorBrush*)Unsafe.AsPointer(ref this), &result);
}
}

131
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1SourceTransform.cs Normal file
View File

@@ -0,0 +1,131 @@
// ------------------------------------------------------------------------------
// <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;
/// <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="ID2D1TransformNode.GetInputCount" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(3)]
public uint GetInputCount()
{
return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, uint>)(lpVtbl[3]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this));
}
/// <inheritdoc cref="ID2D1Transform.MapOutputRectToInputRects" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(4)]
public HResult MapOutputRectToInputRects(RawRect* outputRect, RawRect* inputRects, uint inputRectsCount)
{
return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, RawRect*, RawRect*, uint, int>)(lpVtbl[4]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), outputRect, inputRects, inputRectsCount);
}
/// <inheritdoc cref="ID2D1Transform.MapInputRectsToOutputRect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(5)]
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[5]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
}
/// <inheritdoc cref="ID2D1Transform.MapInvalidRect" />
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[VtblIndex(6)]
public HResult MapInvalidRect(uint inputIndex, RawRect* invalidInputRect, RawRect* invalidOutputRect)
{
return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, uint, RawRect*, RawRect*, int>)(lpVtbl[6]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), inputIndex, invalidInputRect, invalidOutputRect);
}
/// <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, System.Drawing.Point* targetOrigin)
{
return ((delegate* unmanaged[Stdcall]<ID2D1SourceTransform*, ID2D1Bitmap1*, RawRect*, System.Drawing.Point*, int>)(lpVtbl[8]))((ID2D1SourceTransform*)Unsafe.AsPointer(ref this), target, drawRect, targetOrigin);
}
}

131
src/Vortice.Win32/Generated/Graphics/Direct2D/ID2D1SpriteBatch.cs Normal file
View File

@@ -0,0 +1,131 @@
// ------------------------------------------------------------------------------
// <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;
/// <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));
}
}

Some files were not shown because too many files have changed in this diff Show More