diff --git a/.editorconfig b/.editorconfig index c24a7a1..0b5ee6b 100644 --- a/.editorconfig +++ b/.editorconfig @@ -16,9 +16,6 @@ trim_trailing_whitespace = true [*{_AssemblyInfo.cs,.notsupported.cs,AsmOffsets.cs}] generated_code = true -[project.json] -indent_size = 2 - # C# files [*.cs] # New line preferences @@ -34,12 +31,12 @@ csharp_new_line_between_query_expression_clauses = true csharp_indent_block_contents = true csharp_indent_braces = false csharp_indent_case_contents = true -csharp_indent_case_contents_when_block = true +csharp_indent_case_contents_when_block = false csharp_indent_switch_labels = true csharp_indent_labels = one_less_than_current # Modifier preferences -csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:suggestion +csharp_preferred_modifier_order = public,private,protected,internal,file,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,required,volatile,async:suggestion # avoid this. unless absolutely necessary dotnet_style_qualification_for_field = false:suggestion @@ -82,7 +79,7 @@ dotnet_naming_style.camel_case_underscore_style.required_prefix = _ dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case # Code style defaults -csharp_using_directive_placement = outside_namespace:error +csharp_using_directive_placement = outside_namespace:suggestion dotnet_sort_system_directives_first = true csharp_prefer_braces = true:silent csharp_preserve_single_line_blocks = true:none @@ -95,6 +92,7 @@ dotnet_style_readonly_field = true:suggestion # Expression-level preferences dotnet_style_object_initializer = true:suggestion dotnet_style_collection_initializer = true:suggestion +dotnet_style_prefer_collection_expression = when_types_exactly_match dotnet_style_explicit_tuple_names = true:suggestion dotnet_style_coalesce_expression = true:suggestion dotnet_style_null_propagation = true:suggestion @@ -153,8 +151,7 @@ csharp_space_between_method_declaration_name_and_open_parenthesis = false csharp_space_between_method_declaration_parameter_list_parentheses = false csharp_space_between_parentheses = false csharp_space_between_square_brackets = false - -csharp_style_namespace_declarations=file_scoped:error +csharp_style_namespace_declarations = file_scoped:error # License header file_header_template = Copyright (c) Amer Koleci and Contributors.\nLicensed under the MIT License (MIT). See LICENSE in the repository root for more information. @@ -191,4 +188,4 @@ indent_size = 2 [*.sh] end_of_line = lf [*.{cmd,bat}] -end_of_line = crlf +end_of_line = crlf \ No newline at end of file diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 0c5272e..47180bb 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -18,7 +18,7 @@ jobs: steps: - name: Checkout - uses: actions/checkout@v4 + uses: actions/checkout@v5 - name: Setup .NET SDK uses: actions/setup-dotnet@v4 diff --git a/.gitignore b/.gitignore index dae3b69..b165d6e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,260 +1,51 @@ -syntax: glob +# Prerequisites +*.d -#NuGet things -project.lock.json - -### VisualStudio ### - -# User-specific files -*.suo -*.user -*.userosscache -*.sln.docstates - -# Build results -[Dd]ebug/ -[Dd]ebugPublic/ -[Rr]elease/ -[Rr]eleases/ -x64/ -x86/ -bld/ -[Bb]in/ -[Oo]bj/ -msbuild.log - -# Visual Studio 2015 -.vs/ - -# Visual Studio 2015 Pre-CTP6 -*.sln.ide -*.ide/ - -# MSTest test Results -[Tt]est[Rr]esult*/ -[Bb]uild[Ll]og.* - -#NUNIT -*.VisualState.xml -TestResult.xml - -# Build Results of an ATL Project -[Dd]ebugPS/ -[Rr]eleasePS/ -dlldata.c - -*_i.c -*_p.c -*_i.h -*.ilk -*.meta +# Compiled Object files +*.slo +*.lo +*.o *.obj + +# Precompiled Headers +*.gch *.pch -*.pdb -*.pgc -*.pgd -*.rsp -*.sbr -*.tlb -*.tli -*.tlh -*.tmp -*.tmp_proj -*.log -*.vspscc -*.vssscc -.builds -*.pidb -*.svclog -*.scc -# Chutzpah Test files -_Chutzpah* +# Fortran module files +*.mod +*.smod -# Visual C++ cache files -ipch/ -*.aps -*.ncb -*.opensdf -*.sdf -*.cachefile +# Compiled Static libraries +*.lai +*.la +*.a +*.lib -# Visual Studio profiler -*.psess -*.vsp -*.vspx - -# TFS 2012 Local Workspace -$tf/ - -# Guidance Automation Toolkit -*.gpState - -# ReSharper is a .NET coding add-in -_ReSharper*/ -*.[Rr]e[Ss]harper -*.DotSettings.user - -# JustCode is a .NET coding addin-in -.JustCode - -# TeamCity is a build add-in -_TeamCity* - -# DotCover is a Code Coverage Tool -*.dotCover - -# NCrunch -_NCrunch_* -.*crunch*.local.xml - -# MightyMoose -*.mm.* -AutoTest.Net/ - -# Web workbench (sass) -.sass-cache/ - -# Installshield output folder -[Ee]xpress/ - -# DocProject is a documentation generator add-in -DocProject/buildhelp/ -DocProject/Help/*.HxT -DocProject/Help/*.HxC -DocProject/Help/*.hhc -DocProject/Help/*.hhk -DocProject/Help/*.hhp -DocProject/Help/Html2 -DocProject/Help/html - -# Click-Once directory -publish/ - -# Publish Web Output -*.[Pp]ublish.xml -*.azurePubxml -*.pubxml -*.publishproj +# Executables +*.exe +*.out +*.app +*.dmp # NuGet Packages *.nupkg +*.nuget.g.props +*.nuget.g.targets +*.nuget.cache **/packages/* - -# Windows Azure Build Output -csx/ -*.build.csdef - -# Windows Store app package directory -AppPackages/ +project.lock.json +project.assets.json +*.nuget.dgspec.json # Others -sql/ *.Cache -ClientBin/ -[Ss]tyle[Cc]op.* -~$* -*.dbmdl -*.dbproj.schemaview -*.pfx -*.publishsettings -node_modules/ -*.metaproj -*.metaproj.tmp -# RIA/Silverlight projects -Generated_Code/ +# Compiled shaders +*.cso +*.spv -# Backup & report files from converting an old project file -# to a newer Visual Studio version. Backup files are not needed, -# because we have git ;-) -_UpgradeReport_Files/ -Backup*/ -UpgradeLog*.XML -UpgradeLog*.htm - -# SQL Server files -*.mdf -*.ldf - -# Business Intelligence projects -*.rdl.data -*.bim.layout -*.bim_*.settings - -# Microsoft Fakes -FakesAssemblies/ - -### MonoDevelop ### - -*.pidb -*.userprefs - -### Windows ### - -# Windows image file caches -Thumbs.db -ehthumbs.db - -# Folder config file -Desktop.ini - -# Recycle Bin used on file shares -$RECYCLE.BIN/ - -# Windows Installer files -*.cab -*.msi -*.msm -*.msp - -# Windows shortcuts -*.lnk - -### Linux ### - -*~ - -# KDE directory preferences -.directory - -### OSX ### - -.DS_Store -.AppleDouble -.LSOverride - -# Icon must end with two \r -Icon - -# Thumbnails -._* - -# Files that might appear on external disk -.Spotlight-V100 -.Trashes - -# Directories potentially created on remote AFP share -.AppleDB -.AppleDesktop -Network Trash Folder -Temporary Items -.apdisk - -# vim temporary files -[._]*.s[a-w][a-z] -[._]s[a-w][a-z] -*.un~ -Session.vim -.netrwhist -*~ - -*.ini -*.VC.db -*.nvact -*.opendb - -#VS Code stuff - -.vscode -launchSettings.json +# Build dir +.vs +[Bb]in/ +[Oo]bj/ +src/native/build*/ \ No newline at end of file diff --git a/Directory.Build.props b/Directory.Build.props index 49bd7cc..1a40c60 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -11,7 +11,7 @@ - 2.2.7 + 2.3.0 diff --git a/Directory.Packages.props b/Directory.Packages.props index c7f9edf..4ac8f39 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -7,13 +7,13 @@ - - - + + + - - + + diff --git a/Generated/Graphics/Direct2D.Common/Graphics.Direct2D.Common.Enums.cs b/Generated/Graphics/Direct2D.Common/Graphics.Direct2D.Common.Enums.cs new file mode 100644 index 0000000..fdb35db --- /dev/null +++ b/Generated/Graphics/Direct2D.Common/Graphics.Direct2D.Common.Enums.cs @@ -0,0 +1,269 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct2D.Common; + +/// +/// D2D1_ALPHA_MODE +public enum AlphaMode +{ + /// + /// D2D1_ALPHA_MODE_UNKNOWN + Unknown = 0, + /// + /// D2D1_ALPHA_MODE_PREMULTIPLIED + Premultiplied = 1, + /// + /// D2D1_ALPHA_MODE_STRAIGHT + Straight = 2, + /// + /// D2D1_ALPHA_MODE_IGNORE + Ignore = 3, +} + +/// +/// D2D1_FIGURE_BEGIN +public enum FigureBegin +{ + /// + /// D2D1_FIGURE_BEGIN_FILLED + Filled = 0, + /// + /// D2D1_FIGURE_BEGIN_HOLLOW + Hollow = 1, +} + +/// +/// D2D1_FIGURE_END +public enum FigureEnd +{ + /// + /// D2D1_FIGURE_END_OPEN + Open = 0, + /// + /// D2D1_FIGURE_END_CLOSED + Closed = 1, +} + +/// +/// D2D1_PATH_SEGMENT +[Flags] +public enum PathSegment +{ + /// + /// D2D1_PATH_SEGMENT_NONE + None = 0, + /// + /// D2D1_PATH_SEGMENT_FORCE_UNSTROKED + ForceUnstroked = 1, + /// + /// D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN + ForceRoundLineJoin = 2, +} + +/// +/// D2D1_FILL_MODE +public enum FillMode +{ + /// + /// D2D1_FILL_MODE_ALTERNATE + Alternate = 0, + /// + /// D2D1_FILL_MODE_WINDING + Winding = 1, +} + +/// +/// D2D1_BORDER_MODE +public enum BorderMode +{ + /// + /// D2D1_BORDER_MODE_SOFT + Soft = 0, + /// + /// D2D1_BORDER_MODE_HARD + Hard = 1, +} + +/// +/// D2D1_BLEND_MODE +public enum BlendMode +{ + /// + /// D2D1_BLEND_MODE_MULTIPLY + Multiply = 0, + /// + /// D2D1_BLEND_MODE_SCREEN + Screen = 1, + /// + /// D2D1_BLEND_MODE_DARKEN + Darken = 2, + /// + /// D2D1_BLEND_MODE_LIGHTEN + Lighten = 3, + /// + /// D2D1_BLEND_MODE_DISSOLVE + Dissolve = 4, + /// + /// D2D1_BLEND_MODE_COLOR_BURN + ColorBurn = 5, + /// + /// D2D1_BLEND_MODE_LINEAR_BURN + LinearBurn = 6, + /// + /// D2D1_BLEND_MODE_DARKER_COLOR + DarkerColor = 7, + /// + /// D2D1_BLEND_MODE_LIGHTER_COLOR + LighterColor = 8, + /// + /// D2D1_BLEND_MODE_COLOR_DODGE + ColorDodge = 9, + /// + /// D2D1_BLEND_MODE_LINEAR_DODGE + LinearDodge = 10, + /// + /// D2D1_BLEND_MODE_OVERLAY + Overlay = 11, + /// + /// D2D1_BLEND_MODE_SOFT_LIGHT + SoftLight = 12, + /// + /// D2D1_BLEND_MODE_HARD_LIGHT + HardLight = 13, + /// + /// D2D1_BLEND_MODE_VIVID_LIGHT + VividLight = 14, + /// + /// D2D1_BLEND_MODE_LINEAR_LIGHT + LinearLight = 15, + /// + /// D2D1_BLEND_MODE_PIN_LIGHT + PinLight = 16, + /// + /// D2D1_BLEND_MODE_HARD_MIX + HardMix = 17, + /// + /// D2D1_BLEND_MODE_DIFFERENCE + Difference = 18, + /// + /// D2D1_BLEND_MODE_EXCLUSION + Exclusion = 19, + /// + /// D2D1_BLEND_MODE_HUE + Hue = 20, + /// + /// D2D1_BLEND_MODE_SATURATION + Saturation = 21, + /// + /// D2D1_BLEND_MODE_COLOR + Color = 22, + /// + /// D2D1_BLEND_MODE_LUMINOSITY + Luminosity = 23, + /// + /// D2D1_BLEND_MODE_SUBTRACT + Subtract = 24, + /// + /// D2D1_BLEND_MODE_DIVISION + Division = 25, +} + +/// +/// D2D1_COLORMATRIX_ALPHA_MODE +public enum ColorMatrixAlphaMode +{ + /// + /// D2D1_COLORMATRIX_ALPHA_MODE_PREMULTIPLIED + Premultiplied = 1, + /// + /// D2D1_COLORMATRIX_ALPHA_MODE_STRAIGHT + Straight = 2, +} + +/// +/// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE +public enum AffineTransform2DInterpolationMode +{ + /// + /// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR + NearestNeighbor = 0, + /// + /// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR + Linear = 1, + /// + /// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_CUBIC + Cubic = 2, + /// + /// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR + MultiSampleLinear = 3, + /// + /// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC + Anisotropic = 4, + /// + /// D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC + HighQualityCubic = 5, +} + +/// +/// D2D1_TURBULENCE_NOISE +public enum TurbulenceNoise +{ + /// + /// D2D1_TURBULENCE_NOISE_FRACTAL_SUM + FractalSum = 0, + /// + /// D2D1_TURBULENCE_NOISE_TURBULENCE + Turbulence = 1, +} + +/// +/// D2D1_COMPOSITE_MODE +public enum CompositeMode +{ + /// + /// D2D1_COMPOSITE_MODE_SOURCE_OVER + SourceOver = 0, + /// + /// D2D1_COMPOSITE_MODE_DESTINATION_OVER + DestinationOver = 1, + /// + /// D2D1_COMPOSITE_MODE_SOURCE_IN + SourceIn = 2, + /// + /// D2D1_COMPOSITE_MODE_DESTINATION_IN + DestinationIn = 3, + /// + /// D2D1_COMPOSITE_MODE_SOURCE_OUT + SourceOut = 4, + /// + /// D2D1_COMPOSITE_MODE_DESTINATION_OUT + DestinationOut = 5, + /// + /// D2D1_COMPOSITE_MODE_SOURCE_ATOP + SourceAtop = 6, + /// + /// D2D1_COMPOSITE_MODE_DESTINATION_ATOP + DestinationAtop = 7, + /// + /// D2D1_COMPOSITE_MODE_XOR + Xor = 8, + /// + /// D2D1_COMPOSITE_MODE_PLUS + Plus = 9, + /// + /// D2D1_COMPOSITE_MODE_SOURCE_COPY + SourceCopy = 10, + /// + /// D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY + BoundedSourceCopy = 11, + /// + /// D2D1_COMPOSITE_MODE_MASK_INVERT + MaskInvert = 12, +} diff --git a/Generated/Graphics/Direct2D.Common/Graphics.Direct2D.Common.Structs.cs b/Generated/Graphics/Direct2D.Common/Graphics.Direct2D.Common.Structs.cs new file mode 100644 index 0000000..ca214a9 --- /dev/null +++ b/Generated/Graphics/Direct2D.Common/Graphics.Direct2D.Common.Structs.cs @@ -0,0 +1,46 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct2D.Common; + +/// +/// D2D1_PIXEL_FORMAT +public partial struct PixelFormat +{ + /// + public Graphics.Dxgi.Common.Format format; + + /// + public AlphaMode alphaMode; +} + +/// +/// D2D1_GRADIENT_STOP +public partial struct GradientStop +{ + /// + public float position; + + /// + public Color4 color; +} + +/// +/// D2D1_BEZIER_SEGMENT +public partial struct BezierSegment +{ + /// + public Vector2 point1; + + /// + public Vector2 point2; + + /// + public Vector2 point3; +} diff --git a/Generated/Graphics/Direct2D.Common/ID2D1SimplifiedGeometrySink.cs b/Generated/Graphics/Direct2D.Common/ID2D1SimplifiedGeometrySink.cs new file mode 100644 index 0000000..89f245b --- /dev/null +++ b/Generated/Graphics/Direct2D.Common/ID2D1SimplifiedGeometrySink.cs @@ -0,0 +1,153 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct2D.Common; + +/// +/// ID2D1SimplifiedGeometrySink +[Guid("2cd9069e-12e2-11dc-9fed-001143a055f9")] +[NativeTypeName("struct ID2D1SimplifiedGeometrySink : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID2D1SimplifiedGeometrySink : ID2D1SimplifiedGeometrySink.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID2D1SimplifiedGeometrySink + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x9E, 0x06, 0xD9, 0x2C, + 0xE2, 0x12, + 0xDC, 0x11, + 0x9F, + 0xED, + 0x00, + 0x11, + 0x43, + 0xA0, + 0x55, + 0xF9 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID2D1SimplifiedGeometrySink)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void SetFillMode(FillMode fillMode) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), fillMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void SetSegmentFlags(PathSegment vertexFlags) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), vertexFlags); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void BeginFigure(Vector2 startPoint, FigureBegin figureBegin) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), startPoint, figureBegin); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void AddLines(Vector2* points, uint pointsCount) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), points, pointsCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public void AddBeziers(BezierSegment* beziers, uint beziersCount) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[7]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), beziers, beziersCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void EndFigure(FigureEnd figureEnd) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[8]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this), figureEnd); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult Close() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[9]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this)); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + void SetFillMode(FillMode fillMode); + + [VtblIndex(4)] + void SetSegmentFlags(PathSegment vertexFlags); + + [VtblIndex(5)] + void BeginFigure(Vector2 startPoint, FigureBegin figureBegin); + + [VtblIndex(6)] + void AddLines(Vector2* points, uint pointsCount); + + [VtblIndex(7)] + void AddBeziers(BezierSegment* beziers, uint beziersCount); + + [VtblIndex(8)] + void EndFigure(FigureEnd figureEnd); + + [VtblIndex(9)] + HResult Close(); + } +} + diff --git a/Generated/Graphics/Direct3D/Graphics.Direct3D.Apis.cs b/Generated/Graphics/Direct3D/Graphics.Direct3D.Apis.cs new file mode 100644 index 0000000..4f34631 --- /dev/null +++ b/Generated/Graphics/Direct3D/Graphics.Direct3D.Apis.cs @@ -0,0 +1,572 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D; + +public static partial class Apis +{ + public const uint D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION = 2048; + + public const uint D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION = 4096; + + public const uint D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION = 2048; + + public const uint D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION = 4096; + + public const uint D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION = 512; + + public const uint D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION = 4096; + + public const uint D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 256; + + public const uint D3D_FL9_1_DEFAULT_MAX_ANISOTROPY = 2; + + public const uint D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT = 65535; + + public const uint D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT = 1048575; + + public const uint D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT = 1; + + public const uint D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT = 4; + + public const uint D3D_FL9_1_MAX_TEXTURE_REPEAT = 128; + + public const uint D3D_FL9_2_MAX_TEXTURE_REPEAT = 2048; + + public const uint D3D_FL9_3_MAX_TEXTURE_REPEAT = 8192; + + public const uint D3D_SHADER_FEATURE_DOUBLES = 1; + + public const uint D3D_SHADER_FEATURE_COMPUTE_SHADERS_PLUS_RAW_AND_STRUCTURED_BUFFERS_VIA_SHADER_4_X = 2; + + public const uint D3D_SHADER_FEATURE_UAVS_AT_EVERY_STAGE = 4; + + public const uint D3D_SHADER_FEATURE_64_UAVS = 8; + + public const uint D3D_SHADER_FEATURE_MINIMUM_PRECISION = 16; + + public const uint D3D_SHADER_FEATURE_11_1_DOUBLE_EXTENSIONS = 32; + + public const uint D3D_SHADER_FEATURE_11_1_SHADER_EXTENSIONS = 64; + + public const uint D3D_SHADER_FEATURE_LEVEL_9_COMPARISON_FILTERING = 128; + + public const uint D3D_SHADER_FEATURE_TILED_RESOURCES = 256; + + public const uint D3D_SHADER_FEATURE_STENCIL_REF = 512; + + public const uint D3D_SHADER_FEATURE_INNER_COVERAGE = 1024; + + public const uint D3D_SHADER_FEATURE_TYPED_UAV_LOAD_ADDITIONAL_FORMATS = 2048; + + public const uint D3D_SHADER_FEATURE_ROVS = 4096; + + public const uint D3D_SHADER_FEATURE_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER = 8192; + + public const uint D3D_SHADER_FEATURE_WAVE_OPS = 16384; + + public const uint D3D_SHADER_FEATURE_INT64_OPS = 32768; + + public const uint D3D_SHADER_FEATURE_VIEW_ID = 65536; + + public const uint D3D_SHADER_FEATURE_BARYCENTRICS = 131072; + + public const uint D3D_SHADER_FEATURE_NATIVE_16BIT_OPS = 262144; + + public const uint D3D_SHADER_FEATURE_SHADING_RATE = 524288; + + public const uint D3D_SHADER_FEATURE_RAYTRACING_TIER_1_1 = 1048576; + + public const uint D3D_SHADER_FEATURE_SAMPLER_FEEDBACK = 2097152; + + public const uint D3D_SHADER_FEATURE_ATOMIC_INT64_ON_TYPED_RESOURCE = 4194304; + + public const uint D3D_SHADER_FEATURE_ATOMIC_INT64_ON_GROUP_SHARED = 8388608; + + public const uint D3D_SHADER_FEATURE_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS = 16777216; + + public const uint D3D_SHADER_FEATURE_RESOURCE_DESCRIPTOR_HEAP_INDEXING = 33554432; + + public const uint D3D_SHADER_FEATURE_SAMPLER_DESCRIPTOR_HEAP_INDEXING = 67108864; + + public const uint D3D_SHADER_FEATURE_WAVE_MMA = 134217728; + + public const uint D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE = 268435456; + + public const uint D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS = 536870912; + + public const uint D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES = 1073741824; + + public const uint D3D_SHADER_FEATURE_SAMPLE_CMP_GRADIENT_OR_BIAS = 2147483648; + + public static ref readonly Guid WKPDID_D3DDebugObjectName + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x22, 0x8C, 0x9B, 0x42, + 0x88, 0x91, + 0x0C, 0x4B, + 0x87, + 0x42, + 0xAC, + 0xB0, + 0xBF, + 0x85, + 0xC2, + 0x00 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid WKPDID_D3DDebugObjectNameW + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xD8, 0x5F, 0xCA, 0x4C, + 0x1F, 0x92, + 0xC8, 0x42, + 0x85, + 0x66, + 0x70, + 0xCA, + 0xF2, + 0xA9, + 0xB7, + 0x41 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid WKPDID_CommentStringW + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xC0, 0x9D, 0x14, 0xD0, + 0xE8, 0x90, + 0xC8, 0x4E, + 0x81, + 0x44, + 0xE9, + 0x00, + 0xAD, + 0x26, + 0x6B, + 0xB2 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid WKPDID_D3D12UniqueObjectId + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x15, 0xDE, 0x39, 0x1B, + 0x04, 0xEC, + 0xAE, 0x4B, + 0xBA, + 0x4D, + 0x8C, + 0xEF, + 0x79, + 0xFC, + 0x04, + 0xC1 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public const uint D3D_COMPONENT_MASK_X = 1; + + public const uint D3D_COMPONENT_MASK_Y = 2; + + public const uint D3D_COMPONENT_MASK_Z = 4; + + public const uint D3D_COMPONENT_MASK_W = 8; + + public static ref readonly Guid D3D_TEXTURE_LAYOUT_ROW_MAJOR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x4F, 0x23, 0xDC, 0xB5, + 0xBB, 0x72, + 0xEC, 0x4B, + 0x97, + 0x05, + 0x8C, + 0xF2, + 0x58, + 0xDF, + 0x6B, + 0x6C + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xE3, 0x29, 0x0F, 0x4C, + 0x5F, 0x3F, + 0x35, 0x4D, + 0x84, + 0xC9, + 0xBC, + 0x09, + 0x83, + 0xB6, + 0x2C, + 0x28 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public const DriverType D3D_DRIVER_TYPE_UNKNOWN = DriverType.Unknown; + public const DriverType D3D_DRIVER_TYPE_HARDWARE = DriverType.Hardware; + public const DriverType D3D_DRIVER_TYPE_REFERENCE = DriverType.Reference; + public const DriverType D3D_DRIVER_TYPE_NULL = DriverType.Null; + public const DriverType D3D_DRIVER_TYPE_SOFTWARE = DriverType.Software; + public const DriverType D3D_DRIVER_TYPE_WARP = DriverType.Warp; + public const FeatureLevel D3D_FEATURE_LEVEL_1_0_GENERIC = FeatureLevel.Level_1_0_Generic; + public const FeatureLevel D3D_FEATURE_LEVEL_1_0_CORE = FeatureLevel.Level_1_0_Core; + public const FeatureLevel D3D_FEATURE_LEVEL_9_1 = FeatureLevel.Level_9_1; + public const FeatureLevel D3D_FEATURE_LEVEL_9_2 = FeatureLevel.Level_9_2; + public const FeatureLevel D3D_FEATURE_LEVEL_9_3 = FeatureLevel.Level_9_3; + public const FeatureLevel D3D_FEATURE_LEVEL_10_0 = FeatureLevel.Level_10_0; + public const FeatureLevel D3D_FEATURE_LEVEL_10_1 = FeatureLevel.Level_10_1; + public const FeatureLevel D3D_FEATURE_LEVEL_11_0 = FeatureLevel.Level_11_0; + public const FeatureLevel D3D_FEATURE_LEVEL_11_1 = FeatureLevel.Level_11_1; + public const FeatureLevel D3D_FEATURE_LEVEL_12_0 = FeatureLevel.Level_12_0; + public const FeatureLevel D3D_FEATURE_LEVEL_12_1 = FeatureLevel.Level_12_1; + public const FeatureLevel D3D_FEATURE_LEVEL_12_2 = FeatureLevel.Level_12_2; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_UNDEFINED = PrimitiveTopology.Undefined; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_POINTLIST = PrimitiveTopology.PointList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_LINELIST = PrimitiveTopology.LineList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = PrimitiveTopology.LineStrip; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = PrimitiveTopology.TriangleList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = PrimitiveTopology.TriangleStrip; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_TRIANGLEFAN = PrimitiveTopology.TriangleFan; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = PrimitiveTopology.LineListAdj; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = PrimitiveTopology.LineStripAdj; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = PrimitiveTopology.TriangleListAdj; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = PrimitiveTopology.TriangleStripAdj; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P1ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P2ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P3ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P4ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P5ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P6ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P7ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P8ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P9ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P10ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P11ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P12ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P13ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P14ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P15ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P16ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P17ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P18ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P19ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P20ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P21ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P22ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P23ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P24ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P25ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P26ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P27ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P28ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P29ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P30ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P31ControlPointPatchList; + public const PrimitiveTopology D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = PrimitiveTopology.P32ControlPointPatchList; + public const Primitive D3D_PRIMITIVE_UNDEFINED = Primitive.Undefined; + public const Primitive D3D_PRIMITIVE_POINT = Primitive.Point; + public const Primitive D3D_PRIMITIVE_LINE = Primitive.Line; + public const Primitive D3D_PRIMITIVE_TRIANGLE = Primitive.Triangle; + public const Primitive D3D_PRIMITIVE_LINE_ADJ = Primitive.LineAdj; + public const Primitive D3D_PRIMITIVE_TRIANGLE_ADJ = Primitive.TriangleAdj; + public const Primitive D3D_PRIMITIVE_1_CONTROL_POINT_PATCH = Primitive.P1ControlPointPatch; + public const Primitive D3D_PRIMITIVE_2_CONTROL_POINT_PATCH = Primitive.P2ControlPointPatch; + public const Primitive D3D_PRIMITIVE_3_CONTROL_POINT_PATCH = Primitive.P3ControlPointPatch; + public const Primitive D3D_PRIMITIVE_4_CONTROL_POINT_PATCH = Primitive.P4ControlPointPatch; + public const Primitive D3D_PRIMITIVE_5_CONTROL_POINT_PATCH = Primitive.P5ControlPointPatch; + public const Primitive D3D_PRIMITIVE_6_CONTROL_POINT_PATCH = Primitive.P6ControlPointPatch; + public const Primitive D3D_PRIMITIVE_7_CONTROL_POINT_PATCH = Primitive.P7ControlPointPatch; + public const Primitive D3D_PRIMITIVE_8_CONTROL_POINT_PATCH = Primitive.P8ControlPointPatch; + public const Primitive D3D_PRIMITIVE_9_CONTROL_POINT_PATCH = Primitive.P9ControlPointPatch; + public const Primitive D3D_PRIMITIVE_10_CONTROL_POINT_PATCH = Primitive.P10ControlPointPatch; + public const Primitive D3D_PRIMITIVE_11_CONTROL_POINT_PATCH = Primitive.P11ControlPointPatch; + public const Primitive D3D_PRIMITIVE_12_CONTROL_POINT_PATCH = Primitive.P12ControlPointPatch; + public const Primitive D3D_PRIMITIVE_13_CONTROL_POINT_PATCH = Primitive.P13ControlPointPatch; + public const Primitive D3D_PRIMITIVE_14_CONTROL_POINT_PATCH = Primitive.P14ControlPointPatch; + public const Primitive D3D_PRIMITIVE_15_CONTROL_POINT_PATCH = Primitive.P15ControlPointPatch; + public const Primitive D3D_PRIMITIVE_16_CONTROL_POINT_PATCH = Primitive.P16ControlPointPatch; + public const Primitive D3D_PRIMITIVE_17_CONTROL_POINT_PATCH = Primitive.P17ControlPointPatch; + public const Primitive D3D_PRIMITIVE_18_CONTROL_POINT_PATCH = Primitive.P18ControlPointPatch; + public const Primitive D3D_PRIMITIVE_19_CONTROL_POINT_PATCH = Primitive.P19ControlPointPatch; + public const Primitive D3D_PRIMITIVE_20_CONTROL_POINT_PATCH = Primitive.P20ControlPointPatch; + public const Primitive D3D_PRIMITIVE_21_CONTROL_POINT_PATCH = Primitive.P21ControlPointPatch; + public const Primitive D3D_PRIMITIVE_22_CONTROL_POINT_PATCH = Primitive.P22ControlPointPatch; + public const Primitive D3D_PRIMITIVE_23_CONTROL_POINT_PATCH = Primitive.P23ControlPointPatch; + public const Primitive D3D_PRIMITIVE_24_CONTROL_POINT_PATCH = Primitive.P24ControlPointPatch; + public const Primitive D3D_PRIMITIVE_25_CONTROL_POINT_PATCH = Primitive.P25ControlPointPatch; + public const Primitive D3D_PRIMITIVE_26_CONTROL_POINT_PATCH = Primitive.P26ControlPointPatch; + public const Primitive D3D_PRIMITIVE_27_CONTROL_POINT_PATCH = Primitive.P27ControlPointPatch; + public const Primitive D3D_PRIMITIVE_28_CONTROL_POINT_PATCH = Primitive.P28ControlPointPatch; + public const Primitive D3D_PRIMITIVE_29_CONTROL_POINT_PATCH = Primitive.P29ControlPointPatch; + public const Primitive D3D_PRIMITIVE_30_CONTROL_POINT_PATCH = Primitive.P30ControlPointPatch; + public const Primitive D3D_PRIMITIVE_31_CONTROL_POINT_PATCH = Primitive.P31ControlPointPatch; + public const Primitive D3D_PRIMITIVE_32_CONTROL_POINT_PATCH = Primitive.P32ControlPointPatch; + public const SrvDimension D3D_SRV_DIMENSION_UNKNOWN = SrvDimension.Unknown; + public const SrvDimension D3D_SRV_DIMENSION_BUFFER = SrvDimension.Buffer; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE1D = SrvDimension.Texture1D; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE1DARRAY = SrvDimension.Texture1DArray; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE2D = SrvDimension.Texture2D; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE2DARRAY = SrvDimension.Texture2DArray; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE2DMS = SrvDimension.Texture2DMs; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE2DMSARRAY = SrvDimension.Texture2DMsArray; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURE3D = SrvDimension.Texture3D; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURECUBE = SrvDimension.TextureCube; + public const SrvDimension D3D_SRV_DIMENSION_TEXTURECUBEARRAY = SrvDimension.TextureCubeArray; + public const SrvDimension D3D_SRV_DIMENSION_BUFFEREX = SrvDimension.BufferExtended; + public const IncludeType D3D_INCLUDE_LOCAL = IncludeType.Local; + public const IncludeType D3D_INCLUDE_SYSTEM = IncludeType.System; + public const ShaderVariableClass D3D_SVC_SCALAR = ShaderVariableClass.Scalar; + public const ShaderVariableClass D3D_SVC_VECTOR = ShaderVariableClass.Vector; + public const ShaderVariableClass D3D_SVC_MATRIX_ROWS = ShaderVariableClass.MatrixRows; + public const ShaderVariableClass D3D_SVC_MATRIX_COLUMNS = ShaderVariableClass.MatrixColumns; + public const ShaderVariableClass D3D_SVC_OBJECT = ShaderVariableClass.Object; + public const ShaderVariableClass D3D_SVC_STRUCT = ShaderVariableClass.Struct; + public const ShaderVariableClass D3D_SVC_INTERFACE_CLASS = ShaderVariableClass.InterfaceClass; + public const ShaderVariableClass D3D_SVC_INTERFACE_POINTER = ShaderVariableClass.InterfacePointer; + public const ShaderVariableFlags D3D_SVF_USERPACKED = ShaderVariableFlags.UserPacked; + public const ShaderVariableFlags D3D_SVF_USED = ShaderVariableFlags.Used; + public const ShaderVariableFlags D3D_SVF_INTERFACE_POINTER = ShaderVariableFlags.InterfacePointer; + public const ShaderVariableFlags D3D_SVF_INTERFACE_PARAMETER = ShaderVariableFlags.InterfaceParameter; + public const ShaderVariableType D3D_SVT_VOID = ShaderVariableType.Void; + public const ShaderVariableType D3D_SVT_BOOL = ShaderVariableType.Bool; + public const ShaderVariableType D3D_SVT_INT = ShaderVariableType.Int; + public const ShaderVariableType D3D_SVT_FLOAT = ShaderVariableType.Float; + public const ShaderVariableType D3D_SVT_STRING = ShaderVariableType.String; + public const ShaderVariableType D3D_SVT_TEXTURE = ShaderVariableType.Texture; + public const ShaderVariableType D3D_SVT_TEXTURE1D = ShaderVariableType.Texture1D; + public const ShaderVariableType D3D_SVT_TEXTURE2D = ShaderVariableType.Texture2D; + public const ShaderVariableType D3D_SVT_TEXTURE3D = ShaderVariableType.Texture3D; + public const ShaderVariableType D3D_SVT_TEXTURECUBE = ShaderVariableType.TextureCube; + public const ShaderVariableType D3D_SVT_SAMPLER = ShaderVariableType.Sampler; + public const ShaderVariableType D3D_SVT_SAMPLER1D = ShaderVariableType.Sampler1D; + public const ShaderVariableType D3D_SVT_SAMPLER2D = ShaderVariableType.Sampler2D; + public const ShaderVariableType D3D_SVT_SAMPLER3D = ShaderVariableType.Sampler3D; + public const ShaderVariableType D3D_SVT_SAMPLERCUBE = ShaderVariableType.SamplerCube; + public const ShaderVariableType D3D_SVT_PIXELSHADER = ShaderVariableType.PixelShader; + public const ShaderVariableType D3D_SVT_VERTEXSHADER = ShaderVariableType.VertexShader; + public const ShaderVariableType D3D_SVT_PIXELFRAGMENT = ShaderVariableType.PixelFragment; + public const ShaderVariableType D3D_SVT_VERTEXFRAGMENT = ShaderVariableType.VertexFragment; + public const ShaderVariableType D3D_SVT_UINT = ShaderVariableType.Uint; + public const ShaderVariableType D3D_SVT_UINT8 = ShaderVariableType.Uint8; + public const ShaderVariableType D3D_SVT_GEOMETRYSHADER = ShaderVariableType.GeometryShader; + public const ShaderVariableType D3D_SVT_RASTERIZER = ShaderVariableType.Rasterizer; + public const ShaderVariableType D3D_SVT_DEPTHSTENCIL = ShaderVariableType.DepthStencil; + public const ShaderVariableType D3D_SVT_BLEND = ShaderVariableType.Blend; + public const ShaderVariableType D3D_SVT_BUFFER = ShaderVariableType.Buffer; + public const ShaderVariableType D3D_SVT_CBUFFER = ShaderVariableType.ConstantBuffer; + public const ShaderVariableType D3D_SVT_TBUFFER = ShaderVariableType.TextureBuffer; + public const ShaderVariableType D3D_SVT_TEXTURE1DARRAY = ShaderVariableType.Texture1DArray; + public const ShaderVariableType D3D_SVT_TEXTURE2DARRAY = ShaderVariableType.Texture2DArray; + public const ShaderVariableType D3D_SVT_RENDERTARGETVIEW = ShaderVariableType.RenderTargetView; + public const ShaderVariableType D3D_SVT_DEPTHSTENCILVIEW = ShaderVariableType.DepthStencilView; + public const ShaderVariableType D3D_SVT_TEXTURE2DMS = ShaderVariableType.Texture2DMs; + public const ShaderVariableType D3D_SVT_TEXTURE2DMSARRAY = ShaderVariableType.Texture2DMsArray; + public const ShaderVariableType D3D_SVT_TEXTURECUBEARRAY = ShaderVariableType.TextureCubeArray; + public const ShaderVariableType D3D_SVT_HULLSHADER = ShaderVariableType.Hullshader; + public const ShaderVariableType D3D_SVT_DOMAINSHADER = ShaderVariableType.DomainShader; + public const ShaderVariableType D3D_SVT_INTERFACE_POINTER = ShaderVariableType.InterfacePointer; + public const ShaderVariableType D3D_SVT_COMPUTESHADER = ShaderVariableType.ComputeShader; + public const ShaderVariableType D3D_SVT_DOUBLE = ShaderVariableType.Double; + public const ShaderVariableType D3D_SVT_RWTEXTURE1D = ShaderVariableType.RwTexture1D; + public const ShaderVariableType D3D_SVT_RWTEXTURE1DARRAY = ShaderVariableType.RwTexture1DArray; + public const ShaderVariableType D3D_SVT_RWTEXTURE2D = ShaderVariableType.RwTexture2D; + public const ShaderVariableType D3D_SVT_RWTEXTURE2DARRAY = ShaderVariableType.RwTexture2DArray; + public const ShaderVariableType D3D_SVT_RWTEXTURE3D = ShaderVariableType.RwTexture3D; + public const ShaderVariableType D3D_SVT_RWBUFFER = ShaderVariableType.RwBuffer; + public const ShaderVariableType D3D_SVT_BYTEADDRESS_BUFFER = ShaderVariableType.ByteAddressBuffer; + public const ShaderVariableType D3D_SVT_RWBYTEADDRESS_BUFFER = ShaderVariableType.RwByteAddressBuffer; + public const ShaderVariableType D3D_SVT_STRUCTURED_BUFFER = ShaderVariableType.StructuredBuffer; + public const ShaderVariableType D3D_SVT_RWSTRUCTURED_BUFFER = ShaderVariableType.RwStructuredBuffer; + public const ShaderVariableType D3D_SVT_APPEND_STRUCTURED_BUFFER = ShaderVariableType.AppendStructuredBuffer; + public const ShaderVariableType D3D_SVT_CONSUME_STRUCTURED_BUFFER = ShaderVariableType.ConsumeStructuredBuffer; + public const ShaderVariableType D3D_SVT_MIN8FLOAT = ShaderVariableType.Min8Float; + public const ShaderVariableType D3D_SVT_MIN10FLOAT = ShaderVariableType.Min10Float; + public const ShaderVariableType D3D_SVT_MIN16FLOAT = ShaderVariableType.Min16Float; + public const ShaderVariableType D3D_SVT_MIN12INT = ShaderVariableType.Min12Int; + public const ShaderVariableType D3D_SVT_MIN16INT = ShaderVariableType.Min16Int; + public const ShaderVariableType D3D_SVT_MIN16UINT = ShaderVariableType.Min16Uint; + public const ShaderVariableType D3D_SVT_INT16 = ShaderVariableType.Int16; + public const ShaderVariableType D3D_SVT_UINT16 = ShaderVariableType.UInt16; + public const ShaderVariableType D3D_SVT_FLOAT16 = ShaderVariableType.Float16; + public const ShaderVariableType D3D_SVT_INT64 = ShaderVariableType.Int64; + public const ShaderVariableType D3D_SVT_UINT64 = ShaderVariableType.UInt64; + public const ShaderInputFlags D3D_SIF_USERPACKED = ShaderInputFlags.UserPacked; + public const ShaderInputFlags D3D_SIF_COMPARISON_SAMPLER = ShaderInputFlags.ComparisonSampler; + public const ShaderInputFlags D3D_SIF_TEXTURE_COMPONENT_0 = ShaderInputFlags.TextureComponent0; + public const ShaderInputFlags D3D_SIF_TEXTURE_COMPONENT_1 = ShaderInputFlags.TextureComponent1; + public const ShaderInputFlags D3D_SIF_TEXTURE_COMPONENTS = ShaderInputFlags.TextureComponents; + public const ShaderInputFlags D3D_SIF_UNUSED = ShaderInputFlags.Unused; + public const ShaderInputType D3D_SIT_CBUFFER = ShaderInputType.ConstantBuffer; + public const ShaderInputType D3D_SIT_TBUFFER = ShaderInputType.TextureBuffer; + public const ShaderInputType D3D_SIT_TEXTURE = ShaderInputType.Texture; + public const ShaderInputType D3D_SIT_SAMPLER = ShaderInputType.Sampler; + public const ShaderInputType D3D_SIT_UAV_RWTYPED = ShaderInputType.UavRwTyped; + public const ShaderInputType D3D_SIT_STRUCTURED = ShaderInputType.Structured; + public const ShaderInputType D3D_SIT_UAV_RWSTRUCTURED = ShaderInputType.UavRwStructured; + public const ShaderInputType D3D_SIT_BYTEADDRESS = ShaderInputType.ByteAddress; + public const ShaderInputType D3D_SIT_UAV_RWBYTEADDRESS = ShaderInputType.UavRwByteAddress; + public const ShaderInputType D3D_SIT_UAV_APPEND_STRUCTURED = ShaderInputType.UavAppendStructured; + public const ShaderInputType D3D_SIT_UAV_CONSUME_STRUCTURED = ShaderInputType.UavConsumeStructured; + public const ShaderInputType D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = ShaderInputType.UavRwStructuredWithCounter; + public const ShaderInputType D3D_SIT_RTACCELERATIONSTRUCTURE = ShaderInputType.RtAccelerationStructure; + public const ShaderInputType D3D_SIT_UAV_FEEDBACKTEXTURE = ShaderInputType.UavFeedbackTexture; + public const ShaderConstantBufferFlags D3D_CBF_USERPACKED = ShaderConstantBufferFlags.UserPacked; + public const ConstantBufferType D3D_CT_CBUFFER = ConstantBufferType.ConstantBuffer; + public const ConstantBufferType D3D_CT_TBUFFER = ConstantBufferType.TextureBuffer; + public const ConstantBufferType D3D_CT_INTERFACE_POINTERS = ConstantBufferType.InterfacePointers; + public const ConstantBufferType D3D_CT_RESOURCE_BIND_INFO = ConstantBufferType.ResourceBindInfo; + public const Name D3D_NAME_UNDEFINED = Name.Undefined; + public const Name D3D_NAME_POSITION = Name.Position; + public const Name D3D_NAME_CLIP_DISTANCE = Name.ClipDistance; + public const Name D3D_NAME_CULL_DISTANCE = Name.CullDistance; + public const Name D3D_NAME_RENDER_TARGET_ARRAY_INDEX = Name.RenderTargetArrayIndex; + public const Name D3D_NAME_VIEWPORT_ARRAY_INDEX = Name.ViewportArrayIndex; + public const Name D3D_NAME_VERTEX_ID = Name.VertexId; + public const Name D3D_NAME_PRIMITIVE_ID = Name.PrimitiveId; + public const Name D3D_NAME_INSTANCE_ID = Name.InstanceId; + public const Name D3D_NAME_IS_FRONT_FACE = Name.IsFrontFace; + public const Name D3D_NAME_SAMPLE_INDEX = Name.SampleIndex; + public const Name D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR = Name.FinalQuadEdgeTessFactor; + public const Name D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = Name.FinalQuadInsideTessFactor; + public const Name D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR = Name.FinalTriEdgeTessFactor; + public const Name D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR = Name.FinalTriInsideTessFactor; + public const Name D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR = Name.FinalLineDetailTessFactor; + public const Name D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR = Name.FinalLineDensityTessFactor; + public const Name D3D_NAME_BARYCENTRICS = Name.Barycentrics; + public const Name D3D_NAME_SHADINGRATE = Name.ShadingRate; + public const Name D3D_NAME_CULLPRIMITIVE = Name.CullPrimitive; + public const Name D3D_NAME_TARGET = Name.Target; + public const Name D3D_NAME_DEPTH = Name.Depth; + public const Name D3D_NAME_COVERAGE = Name.Coverage; + public const Name D3D_NAME_DEPTH_GREATER_EQUAL = Name.DepthGreaterEqual; + public const Name D3D_NAME_DEPTH_LESS_EQUAL = Name.DepthLessEqual; + public const Name D3D_NAME_STENCIL_REF = Name.StencilRef; + public const Name D3D_NAME_INNER_COVERAGE = Name.InnerCoverage; + public const ResourceReturnType D3D_RETURN_TYPE_UNORM = ResourceReturnType.Unorm; + public const ResourceReturnType D3D_RETURN_TYPE_SNORM = ResourceReturnType.Snorm; + public const ResourceReturnType D3D_RETURN_TYPE_SINT = ResourceReturnType.Sint; + public const ResourceReturnType D3D_RETURN_TYPE_UINT = ResourceReturnType.Uint; + public const ResourceReturnType D3D_RETURN_TYPE_FLOAT = ResourceReturnType.Float; + public const ResourceReturnType D3D_RETURN_TYPE_MIXED = ResourceReturnType.Mixed; + public const ResourceReturnType D3D_RETURN_TYPE_DOUBLE = ResourceReturnType.Double; + public const ResourceReturnType D3D_RETURN_TYPE_CONTINUED = ResourceReturnType.Continued; + public const RegisterComponentType D3D_REGISTER_COMPONENT_UNKNOWN = RegisterComponentType.Unknown; + public const RegisterComponentType D3D_REGISTER_COMPONENT_UINT32 = RegisterComponentType.UInt32; + public const RegisterComponentType D3D_REGISTER_COMPONENT_SINT32 = RegisterComponentType.Sint32; + public const RegisterComponentType D3D_REGISTER_COMPONENT_FLOAT32 = RegisterComponentType.Float32; + public const RegisterComponentType D3D_REGISTER_COMPONENT_UINT16 = RegisterComponentType.UInt16; + public const RegisterComponentType D3D_REGISTER_COMPONENT_SINT16 = RegisterComponentType.Sint16; + public const RegisterComponentType D3D_REGISTER_COMPONENT_FLOAT16 = RegisterComponentType.Float16; + public const RegisterComponentType D3D_REGISTER_COMPONENT_UINT64 = RegisterComponentType.UInt64; + public const RegisterComponentType D3D_REGISTER_COMPONENT_SINT64 = RegisterComponentType.Sint64; + public const RegisterComponentType D3D_REGISTER_COMPONENT_FLOAT64 = RegisterComponentType.Float64; + public const TessellatorDomain D3D_TESSELLATOR_DOMAIN_UNDEFINED = TessellatorDomain.Undefined; + public const TessellatorDomain D3D_TESSELLATOR_DOMAIN_ISOLINE = TessellatorDomain.Isoline; + public const TessellatorDomain D3D_TESSELLATOR_DOMAIN_TRI = TessellatorDomain.Tri; + public const TessellatorDomain D3D_TESSELLATOR_DOMAIN_QUAD = TessellatorDomain.Quad; + public const TessellatorPartitioning D3D_TESSELLATOR_PARTITIONING_UNDEFINED = TessellatorPartitioning.Undefined; + public const TessellatorPartitioning D3D_TESSELLATOR_PARTITIONING_INTEGER = TessellatorPartitioning.Integer; + public const TessellatorPartitioning D3D_TESSELLATOR_PARTITIONING_POW2 = TessellatorPartitioning.Pow2; + public const TessellatorPartitioning D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = TessellatorPartitioning.FractionalOdd; + public const TessellatorPartitioning D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = TessellatorPartitioning.FractionalEven; + public const TessellatorOutputPrimitive D3D_TESSELLATOR_OUTPUT_UNDEFINED = TessellatorOutputPrimitive.Undefined; + public const TessellatorOutputPrimitive D3D_TESSELLATOR_OUTPUT_POINT = TessellatorOutputPrimitive.Point; + public const TessellatorOutputPrimitive D3D_TESSELLATOR_OUTPUT_LINE = TessellatorOutputPrimitive.Line; + public const TessellatorOutputPrimitive D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW = TessellatorOutputPrimitive.TriangleCw; + public const TessellatorOutputPrimitive D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW = TessellatorOutputPrimitive.TriangleCcw; + public const MinPrecision D3D_MIN_PRECISION_DEFAULT = MinPrecision.Default; + public const MinPrecision D3D_MIN_PRECISION_FLOAT_16 = MinPrecision.Float16; + public const MinPrecision D3D_MIN_PRECISION_FLOAT_2_8 = MinPrecision.Float28; + public const MinPrecision D3D_MIN_PRECISION_RESERVED = MinPrecision.Reserved; + public const MinPrecision D3D_MIN_PRECISION_SINT_16 = MinPrecision.Sint16; + public const MinPrecision D3D_MIN_PRECISION_UINT_16 = MinPrecision.Uint16; + public const MinPrecision D3D_MIN_PRECISION_ANY_16 = MinPrecision.Any16; + public const MinPrecision D3D_MIN_PRECISION_ANY_10 = MinPrecision.Any10; + public const InterpolationMode D3D_INTERPOLATION_UNDEFINED = InterpolationMode.Undefined; + public const InterpolationMode D3D_INTERPOLATION_CONSTANT = InterpolationMode.Constant; + public const InterpolationMode D3D_INTERPOLATION_LINEAR = InterpolationMode.Linear; + public const InterpolationMode D3D_INTERPOLATION_LINEAR_CENTROID = InterpolationMode.LinearCentroid; + public const InterpolationMode D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE = InterpolationMode.LinearNoPerspective; + public const InterpolationMode D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID = InterpolationMode.LinearNoPerspectiveCentroid; + public const InterpolationMode D3D_INTERPOLATION_LINEAR_SAMPLE = InterpolationMode.LinearSample; + public const InterpolationMode D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE = InterpolationMode.LinearNoPerspectiveSample; + public const ParameterFlags D3D_PF_NONE = ParameterFlags.None; + public const ParameterFlags D3D_PF_IN = ParameterFlags.In; + public const ParameterFlags D3D_PF_OUT = ParameterFlags.Out; + public const FormatLayout D3DFL_STANDARD = FormatLayout.D3DFL_STANDARD; + public const FormatLayout D3DFL_CUSTOM = FormatLayout.D3DFL_CUSTOM; + public const FormatTypeLevel D3DFTL_NO_TYPE = FormatTypeLevel.D3DFTL_NO_TYPE; + public const FormatTypeLevel D3DFTL_PARTIAL_TYPE = FormatTypeLevel.D3DFTL_PARTIAL_TYPE; + public const FormatTypeLevel D3DFTL_FULL_TYPE = FormatTypeLevel.D3DFTL_FULL_TYPE; + public const FormatComponentName D3DFCN_R = FormatComponentName.D3DFCN_R; + public const FormatComponentName D3DFCN_G = FormatComponentName.D3DFCN_G; + public const FormatComponentName D3DFCN_B = FormatComponentName.D3DFCN_B; + public const FormatComponentName D3DFCN_A = FormatComponentName.D3DFCN_A; + public const FormatComponentName D3DFCN_D = FormatComponentName.D3DFCN_D; + public const FormatComponentName D3DFCN_S = FormatComponentName.D3DFCN_S; + public const FormatComponentName D3DFCN_X = FormatComponentName.D3DFCN_X; + public const FormatComponentInterpretation D3DFCI_TYPELESS = FormatComponentInterpretation.D3DFCI_TYPELESS; + public const FormatComponentInterpretation D3DFCI_FLOAT = FormatComponentInterpretation.D3DFCI_FLOAT; + public const FormatComponentInterpretation D3DFCI_SNORM = FormatComponentInterpretation.D3DFCI_SNORM; + public const FormatComponentInterpretation D3DFCI_UNORM = FormatComponentInterpretation.D3DFCI_UNORM; + public const FormatComponentInterpretation D3DFCI_SINT = FormatComponentInterpretation.D3DFCI_SINT; + public const FormatComponentInterpretation D3DFCI_UINT = FormatComponentInterpretation.D3DFCI_UINT; + public const FormatComponentInterpretation D3DFCI_UNORM_SRGB = FormatComponentInterpretation.D3DFCI_UNORM_SRGB; + public const FormatComponentInterpretation D3DFCI_BIASED_FIXED_2_8 = FormatComponentInterpretation.D3DFCI_BIASED_FIXED_2_8; +} + diff --git a/Generated/Graphics/Direct3D/Graphics.Direct3D.Enums.cs b/Generated/Graphics/Direct3D/Graphics.Direct3D.Enums.cs new file mode 100644 index 0000000..0095de2 --- /dev/null +++ b/Generated/Graphics/Direct3D/Graphics.Direct3D.Enums.cs @@ -0,0 +1,1106 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D; + +/// +/// D3D_DRIVER_TYPE +public enum DriverType +{ + /// + /// D3D_DRIVER_TYPE_UNKNOWN + Unknown = 0, + /// + /// D3D_DRIVER_TYPE_HARDWARE + Hardware = 1, + /// + /// D3D_DRIVER_TYPE_REFERENCE + Reference = 2, + /// + /// D3D_DRIVER_TYPE_NULL + Null = 3, + /// + /// D3D_DRIVER_TYPE_SOFTWARE + Software = 4, + /// + /// D3D_DRIVER_TYPE_WARP + Warp = 5, +} + +/// +/// D3D_FEATURE_LEVEL +public enum FeatureLevel +{ + /// + /// D3D_FEATURE_LEVEL_1_0_GENERIC + Level_1_0_Generic = 256, + /// + /// D3D_FEATURE_LEVEL_1_0_CORE + Level_1_0_Core = 4096, + /// + /// D3D_FEATURE_LEVEL_9_1 + Level_9_1 = 37120, + /// + /// D3D_FEATURE_LEVEL_9_2 + Level_9_2 = 37376, + /// + /// D3D_FEATURE_LEVEL_9_3 + Level_9_3 = 37632, + /// + /// D3D_FEATURE_LEVEL_10_0 + Level_10_0 = 40960, + /// + /// D3D_FEATURE_LEVEL_10_1 + Level_10_1 = 41216, + /// + /// D3D_FEATURE_LEVEL_11_0 + Level_11_0 = 45056, + /// + /// D3D_FEATURE_LEVEL_11_1 + Level_11_1 = 45312, + /// + /// D3D_FEATURE_LEVEL_12_0 + Level_12_0 = 49152, + /// + /// D3D_FEATURE_LEVEL_12_1 + Level_12_1 = 49408, + /// + /// D3D_FEATURE_LEVEL_12_2 + Level_12_2 = 49664, +} + +/// +/// D3D_PRIMITIVE_TOPOLOGY +public enum PrimitiveTopology +{ + /// + /// D3D_PRIMITIVE_TOPOLOGY_UNDEFINED + Undefined = 0, + /// + /// D3D_PRIMITIVE_TOPOLOGY_POINTLIST + PointList = 1, + /// + /// D3D_PRIMITIVE_TOPOLOGY_LINELIST + LineList = 2, + /// + /// D3D_PRIMITIVE_TOPOLOGY_LINESTRIP + LineStrip = 3, + /// + /// D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST + TriangleList = 4, + /// + /// D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP + TriangleStrip = 5, + /// + /// D3D_PRIMITIVE_TOPOLOGY_TRIANGLEFAN + TriangleFan = 6, + /// + /// D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ + LineListAdj = 10, + /// + /// D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ + LineStripAdj = 11, + /// + /// D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ + TriangleListAdj = 12, + /// + /// D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ + TriangleStripAdj = 13, + /// + /// D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + P1ControlPointPatchList = 33, + /// + /// D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST + P2ControlPointPatchList = 34, + /// + /// D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST + P3ControlPointPatchList = 35, + /// + /// D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST + P4ControlPointPatchList = 36, + /// + /// D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST + P5ControlPointPatchList = 37, + /// + /// D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST + P6ControlPointPatchList = 38, + /// + /// D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST + P7ControlPointPatchList = 39, + /// + /// D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST + P8ControlPointPatchList = 40, + /// + /// D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST + P9ControlPointPatchList = 41, + /// + /// D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST + P10ControlPointPatchList = 42, + /// + /// D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST + P11ControlPointPatchList = 43, + /// + /// D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST + P12ControlPointPatchList = 44, + /// + /// D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST + P13ControlPointPatchList = 45, + /// + /// D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST + P14ControlPointPatchList = 46, + /// + /// D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST + P15ControlPointPatchList = 47, + /// + /// D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST + P16ControlPointPatchList = 48, + /// + /// D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST + P17ControlPointPatchList = 49, + /// + /// D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST + P18ControlPointPatchList = 50, + /// + /// D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST + P19ControlPointPatchList = 51, + /// + /// D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST + P20ControlPointPatchList = 52, + /// + /// D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST + P21ControlPointPatchList = 53, + /// + /// D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST + P22ControlPointPatchList = 54, + /// + /// D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST + P23ControlPointPatchList = 55, + /// + /// D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST + P24ControlPointPatchList = 56, + /// + /// D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST + P25ControlPointPatchList = 57, + /// + /// D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST + P26ControlPointPatchList = 58, + /// + /// D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST + P27ControlPointPatchList = 59, + /// + /// D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST + P28ControlPointPatchList = 60, + /// + /// D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST + P29ControlPointPatchList = 61, + /// + /// D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST + P30ControlPointPatchList = 62, + /// + /// D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST + P31ControlPointPatchList = 63, + /// + /// D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST + P32ControlPointPatchList = 64, +} + +/// +/// D3D_PRIMITIVE +public enum Primitive +{ + /// + /// D3D_PRIMITIVE_UNDEFINED + Undefined = 0, + /// + /// D3D_PRIMITIVE_POINT + Point = 1, + /// + /// D3D_PRIMITIVE_LINE + Line = 2, + /// + /// D3D_PRIMITIVE_TRIANGLE + Triangle = 3, + /// + /// D3D_PRIMITIVE_LINE_ADJ + LineAdj = 6, + /// + /// D3D_PRIMITIVE_TRIANGLE_ADJ + TriangleAdj = 7, + /// + /// D3D_PRIMITIVE_1_CONTROL_POINT_PATCH + P1ControlPointPatch = 8, + /// + /// D3D_PRIMITIVE_2_CONTROL_POINT_PATCH + P2ControlPointPatch = 9, + /// + /// D3D_PRIMITIVE_3_CONTROL_POINT_PATCH + P3ControlPointPatch = 10, + /// + /// D3D_PRIMITIVE_4_CONTROL_POINT_PATCH + P4ControlPointPatch = 11, + /// + /// D3D_PRIMITIVE_5_CONTROL_POINT_PATCH + P5ControlPointPatch = 12, + /// + /// D3D_PRIMITIVE_6_CONTROL_POINT_PATCH + P6ControlPointPatch = 13, + /// + /// D3D_PRIMITIVE_7_CONTROL_POINT_PATCH + P7ControlPointPatch = 14, + /// + /// D3D_PRIMITIVE_8_CONTROL_POINT_PATCH + P8ControlPointPatch = 15, + /// + /// D3D_PRIMITIVE_9_CONTROL_POINT_PATCH + P9ControlPointPatch = 16, + /// + /// D3D_PRIMITIVE_10_CONTROL_POINT_PATCH + P10ControlPointPatch = 17, + /// + /// D3D_PRIMITIVE_11_CONTROL_POINT_PATCH + P11ControlPointPatch = 18, + /// + /// D3D_PRIMITIVE_12_CONTROL_POINT_PATCH + P12ControlPointPatch = 19, + /// + /// D3D_PRIMITIVE_13_CONTROL_POINT_PATCH + P13ControlPointPatch = 20, + /// + /// D3D_PRIMITIVE_14_CONTROL_POINT_PATCH + P14ControlPointPatch = 21, + /// + /// D3D_PRIMITIVE_15_CONTROL_POINT_PATCH + P15ControlPointPatch = 22, + /// + /// D3D_PRIMITIVE_16_CONTROL_POINT_PATCH + P16ControlPointPatch = 23, + /// + /// D3D_PRIMITIVE_17_CONTROL_POINT_PATCH + P17ControlPointPatch = 24, + /// + /// D3D_PRIMITIVE_18_CONTROL_POINT_PATCH + P18ControlPointPatch = 25, + /// + /// D3D_PRIMITIVE_19_CONTROL_POINT_PATCH + P19ControlPointPatch = 26, + /// + /// D3D_PRIMITIVE_20_CONTROL_POINT_PATCH + P20ControlPointPatch = 27, + /// + /// D3D_PRIMITIVE_21_CONTROL_POINT_PATCH + P21ControlPointPatch = 28, + /// + /// D3D_PRIMITIVE_22_CONTROL_POINT_PATCH + P22ControlPointPatch = 29, + /// + /// D3D_PRIMITIVE_23_CONTROL_POINT_PATCH + P23ControlPointPatch = 30, + /// + /// D3D_PRIMITIVE_24_CONTROL_POINT_PATCH + P24ControlPointPatch = 31, + /// + /// D3D_PRIMITIVE_25_CONTROL_POINT_PATCH + P25ControlPointPatch = 32, + /// + /// D3D_PRIMITIVE_26_CONTROL_POINT_PATCH + P26ControlPointPatch = 33, + /// + /// D3D_PRIMITIVE_27_CONTROL_POINT_PATCH + P27ControlPointPatch = 34, + /// + /// D3D_PRIMITIVE_28_CONTROL_POINT_PATCH + P28ControlPointPatch = 35, + /// + /// D3D_PRIMITIVE_29_CONTROL_POINT_PATCH + P29ControlPointPatch = 36, + /// + /// D3D_PRIMITIVE_30_CONTROL_POINT_PATCH + P30ControlPointPatch = 37, + /// + /// D3D_PRIMITIVE_31_CONTROL_POINT_PATCH + P31ControlPointPatch = 38, + /// + /// D3D_PRIMITIVE_32_CONTROL_POINT_PATCH + P32ControlPointPatch = 39, +} + +/// +/// D3D_SRV_DIMENSION +public enum SrvDimension +{ + /// + /// D3D_SRV_DIMENSION_UNKNOWN + Unknown = 0, + /// + /// D3D_SRV_DIMENSION_BUFFER + Buffer = 1, + /// + /// D3D_SRV_DIMENSION_TEXTURE1D + Texture1D = 2, + /// + /// D3D_SRV_DIMENSION_TEXTURE1DARRAY + Texture1DArray = 3, + /// + /// D3D_SRV_DIMENSION_TEXTURE2D + Texture2D = 4, + /// + /// D3D_SRV_DIMENSION_TEXTURE2DARRAY + Texture2DArray = 5, + /// + /// D3D_SRV_DIMENSION_TEXTURE2DMS + Texture2DMs = 6, + /// + /// D3D_SRV_DIMENSION_TEXTURE2DMSARRAY + Texture2DMsArray = 7, + /// + /// D3D_SRV_DIMENSION_TEXTURE3D + Texture3D = 8, + /// + /// D3D_SRV_DIMENSION_TEXTURECUBE + TextureCube = 9, + /// + /// D3D_SRV_DIMENSION_TEXTURECUBEARRAY + TextureCubeArray = 10, + /// + /// D3D_SRV_DIMENSION_BUFFEREX + BufferExtended = 11, +} + +/// +/// D3D_INCLUDE_TYPE +public enum IncludeType +{ + /// + /// D3D_INCLUDE_LOCAL + Local = 0, + /// + /// D3D_INCLUDE_SYSTEM + System = 1, +} + +/// +/// D3D_SHADER_VARIABLE_CLASS +public enum ShaderVariableClass +{ + /// + /// D3D_SVC_SCALAR + Scalar = 0, + /// + /// D3D_SVC_VECTOR + Vector = 1, + /// + /// D3D_SVC_MATRIX_ROWS + MatrixRows = 2, + /// + /// D3D_SVC_MATRIX_COLUMNS + MatrixColumns = 3, + /// + /// D3D_SVC_OBJECT + Object = 4, + /// + /// D3D_SVC_STRUCT + Struct = 5, + /// + /// D3D_SVC_INTERFACE_CLASS + InterfaceClass = 6, + /// + /// D3D_SVC_INTERFACE_POINTER + InterfacePointer = 7, +} + +/// +/// D3D_SHADER_VARIABLE_FLAGS +[Flags] +public enum ShaderVariableFlags +{ + None = 0, + /// + /// D3D_SVF_USERPACKED + UserPacked = 1, + /// + /// D3D_SVF_USED + Used = 2, + /// + /// D3D_SVF_INTERFACE_POINTER + InterfacePointer = 4, + /// + /// D3D_SVF_INTERFACE_PARAMETER + InterfaceParameter = 8, +} + +/// +/// D3D_SHADER_VARIABLE_TYPE +public enum ShaderVariableType +{ + /// + /// D3D_SVT_VOID + Void = 0, + /// + /// D3D_SVT_BOOL + Bool = 1, + /// + /// D3D_SVT_INT + Int = 2, + /// + /// D3D_SVT_FLOAT + Float = 3, + /// + /// D3D_SVT_STRING + String = 4, + /// + /// D3D_SVT_TEXTURE + Texture = 5, + /// + /// D3D_SVT_TEXTURE1D + Texture1D = 6, + /// + /// D3D_SVT_TEXTURE2D + Texture2D = 7, + /// + /// D3D_SVT_TEXTURE3D + Texture3D = 8, + /// + /// D3D_SVT_TEXTURECUBE + TextureCube = 9, + /// + /// D3D_SVT_SAMPLER + Sampler = 10, + /// + /// D3D_SVT_SAMPLER1D + Sampler1D = 11, + /// + /// D3D_SVT_SAMPLER2D + Sampler2D = 12, + /// + /// D3D_SVT_SAMPLER3D + Sampler3D = 13, + /// + /// D3D_SVT_SAMPLERCUBE + SamplerCube = 14, + /// + /// D3D_SVT_PIXELSHADER + PixelShader = 15, + /// + /// D3D_SVT_VERTEXSHADER + VertexShader = 16, + /// + /// D3D_SVT_PIXELFRAGMENT + PixelFragment = 17, + /// + /// D3D_SVT_VERTEXFRAGMENT + VertexFragment = 18, + /// + /// D3D_SVT_UINT + Uint = 19, + /// + /// D3D_SVT_UINT8 + Uint8 = 20, + /// + /// D3D_SVT_GEOMETRYSHADER + GeometryShader = 21, + /// + /// D3D_SVT_RASTERIZER + Rasterizer = 22, + /// + /// D3D_SVT_DEPTHSTENCIL + DepthStencil = 23, + /// + /// D3D_SVT_BLEND + Blend = 24, + /// + /// D3D_SVT_BUFFER + Buffer = 25, + /// + /// D3D_SVT_CBUFFER + ConstantBuffer = 26, + /// + /// D3D_SVT_TBUFFER + TextureBuffer = 27, + /// + /// D3D_SVT_TEXTURE1DARRAY + Texture1DArray = 28, + /// + /// D3D_SVT_TEXTURE2DARRAY + Texture2DArray = 29, + /// + /// D3D_SVT_RENDERTARGETVIEW + RenderTargetView = 30, + /// + /// D3D_SVT_DEPTHSTENCILVIEW + DepthStencilView = 31, + /// + /// D3D_SVT_TEXTURE2DMS + Texture2DMs = 32, + /// + /// D3D_SVT_TEXTURE2DMSARRAY + Texture2DMsArray = 33, + /// + /// D3D_SVT_TEXTURECUBEARRAY + TextureCubeArray = 34, + /// + /// D3D_SVT_HULLSHADER + Hullshader = 35, + /// + /// D3D_SVT_DOMAINSHADER + DomainShader = 36, + /// + /// D3D_SVT_INTERFACE_POINTER + InterfacePointer = 37, + /// + /// D3D_SVT_COMPUTESHADER + ComputeShader = 38, + /// + /// D3D_SVT_DOUBLE + Double = 39, + /// + /// D3D_SVT_RWTEXTURE1D + RwTexture1D = 40, + /// + /// D3D_SVT_RWTEXTURE1DARRAY + RwTexture1DArray = 41, + /// + /// D3D_SVT_RWTEXTURE2D + RwTexture2D = 42, + /// + /// D3D_SVT_RWTEXTURE2DARRAY + RwTexture2DArray = 43, + /// + /// D3D_SVT_RWTEXTURE3D + RwTexture3D = 44, + /// + /// D3D_SVT_RWBUFFER + RwBuffer = 45, + /// + /// D3D_SVT_BYTEADDRESS_BUFFER + ByteAddressBuffer = 46, + /// + /// D3D_SVT_RWBYTEADDRESS_BUFFER + RwByteAddressBuffer = 47, + /// + /// D3D_SVT_STRUCTURED_BUFFER + StructuredBuffer = 48, + /// + /// D3D_SVT_RWSTRUCTURED_BUFFER + RwStructuredBuffer = 49, + /// + /// D3D_SVT_APPEND_STRUCTURED_BUFFER + AppendStructuredBuffer = 50, + /// + /// D3D_SVT_CONSUME_STRUCTURED_BUFFER + ConsumeStructuredBuffer = 51, + /// + /// D3D_SVT_MIN8FLOAT + Min8Float = 52, + /// + /// D3D_SVT_MIN10FLOAT + Min10Float = 53, + /// + /// D3D_SVT_MIN16FLOAT + Min16Float = 54, + /// + /// D3D_SVT_MIN12INT + Min12Int = 55, + /// + /// D3D_SVT_MIN16INT + Min16Int = 56, + /// + /// D3D_SVT_MIN16UINT + Min16Uint = 57, + /// + /// D3D_SVT_INT16 + Int16 = 58, + /// + /// D3D_SVT_UINT16 + UInt16 = 59, + /// + /// D3D_SVT_FLOAT16 + Float16 = 60, + /// + /// D3D_SVT_INT64 + Int64 = 61, + /// + /// D3D_SVT_UINT64 + UInt64 = 62, +} + +/// +/// D3D_SHADER_INPUT_FLAGS +[Flags] +public enum ShaderInputFlags +{ + None = 0, + /// + /// D3D_SIF_USERPACKED + UserPacked = 1, + /// + /// D3D_SIF_COMPARISON_SAMPLER + ComparisonSampler = 2, + /// + /// D3D_SIF_TEXTURE_COMPONENT_0 + TextureComponent0 = 4, + /// + /// D3D_SIF_TEXTURE_COMPONENT_1 + TextureComponent1 = 8, + /// + /// D3D_SIF_TEXTURE_COMPONENTS + TextureComponents = 12, + /// + /// D3D_SIF_UNUSED + Unused = 16, +} + +/// +/// D3D_SHADER_INPUT_TYPE +public enum ShaderInputType +{ + /// + /// D3D_SIT_CBUFFER + ConstantBuffer = 0, + /// + /// D3D_SIT_TBUFFER + TextureBuffer = 1, + /// + /// D3D_SIT_TEXTURE + Texture = 2, + /// + /// D3D_SIT_SAMPLER + Sampler = 3, + /// + /// D3D_SIT_UAV_RWTYPED + UavRwTyped = 4, + /// + /// D3D_SIT_STRUCTURED + Structured = 5, + /// + /// D3D_SIT_UAV_RWSTRUCTURED + UavRwStructured = 6, + /// + /// D3D_SIT_BYTEADDRESS + ByteAddress = 7, + /// + /// D3D_SIT_UAV_RWBYTEADDRESS + UavRwByteAddress = 8, + /// + /// D3D_SIT_UAV_APPEND_STRUCTURED + UavAppendStructured = 9, + /// + /// D3D_SIT_UAV_CONSUME_STRUCTURED + UavConsumeStructured = 10, + /// + /// D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER + UavRwStructuredWithCounter = 11, + /// + /// D3D_SIT_RTACCELERATIONSTRUCTURE + RtAccelerationStructure = 12, + /// + /// D3D_SIT_UAV_FEEDBACKTEXTURE + UavFeedbackTexture = 13, +} + +/// +/// D3D_SHADER_CBUFFER_FLAGS +[Flags] +public enum ShaderConstantBufferFlags +{ + None = 0, + /// + /// D3D_CBF_USERPACKED + UserPacked = 1, +} + +/// +/// D3D_CBUFFER_TYPE +public enum ConstantBufferType +{ + /// + /// D3D_CT_CBUFFER + ConstantBuffer = 0, + /// + /// D3D_CT_TBUFFER + TextureBuffer = 1, + /// + /// D3D_CT_INTERFACE_POINTERS + InterfacePointers = 2, + /// + /// D3D_CT_RESOURCE_BIND_INFO + ResourceBindInfo = 3, +} + +/// +/// D3D_NAME +public enum Name +{ + /// + /// D3D_NAME_UNDEFINED + Undefined = 0, + /// + /// D3D_NAME_POSITION + Position = 1, + /// + /// D3D_NAME_CLIP_DISTANCE + ClipDistance = 2, + /// + /// D3D_NAME_CULL_DISTANCE + CullDistance = 3, + /// + /// D3D_NAME_RENDER_TARGET_ARRAY_INDEX + RenderTargetArrayIndex = 4, + /// + /// D3D_NAME_VIEWPORT_ARRAY_INDEX + ViewportArrayIndex = 5, + /// + /// D3D_NAME_VERTEX_ID + VertexId = 6, + /// + /// D3D_NAME_PRIMITIVE_ID + PrimitiveId = 7, + /// + /// D3D_NAME_INSTANCE_ID + InstanceId = 8, + /// + /// D3D_NAME_IS_FRONT_FACE + IsFrontFace = 9, + /// + /// D3D_NAME_SAMPLE_INDEX + SampleIndex = 10, + /// + /// D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR + FinalQuadEdgeTessFactor = 11, + /// + /// D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR + FinalQuadInsideTessFactor = 12, + /// + /// D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR + FinalTriEdgeTessFactor = 13, + /// + /// D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR + FinalTriInsideTessFactor = 14, + /// + /// D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR + FinalLineDetailTessFactor = 15, + /// + /// D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR + FinalLineDensityTessFactor = 16, + /// + /// D3D_NAME_BARYCENTRICS + Barycentrics = 23, + /// + /// D3D_NAME_SHADINGRATE + ShadingRate = 24, + /// + /// D3D_NAME_CULLPRIMITIVE + CullPrimitive = 25, + /// + /// D3D_NAME_TARGET + Target = 64, + /// + /// D3D_NAME_DEPTH + Depth = 65, + /// + /// D3D_NAME_COVERAGE + Coverage = 66, + /// + /// D3D_NAME_DEPTH_GREATER_EQUAL + DepthGreaterEqual = 67, + /// + /// D3D_NAME_DEPTH_LESS_EQUAL + DepthLessEqual = 68, + /// + /// D3D_NAME_STENCIL_REF + StencilRef = 69, + /// + /// D3D_NAME_INNER_COVERAGE + InnerCoverage = 70, +} + +/// +/// D3D_RESOURCE_RETURN_TYPE +public enum ResourceReturnType +{ + /// + /// D3D_RETURN_TYPE_UNORM + Unorm = 1, + /// + /// D3D_RETURN_TYPE_SNORM + Snorm = 2, + /// + /// D3D_RETURN_TYPE_SINT + Sint = 3, + /// + /// D3D_RETURN_TYPE_UINT + Uint = 4, + /// + /// D3D_RETURN_TYPE_FLOAT + Float = 5, + /// + /// D3D_RETURN_TYPE_MIXED + Mixed = 6, + /// + /// D3D_RETURN_TYPE_DOUBLE + Double = 7, + /// + /// D3D_RETURN_TYPE_CONTINUED + Continued = 8, +} + +/// +/// D3D_REGISTER_COMPONENT_TYPE +public enum RegisterComponentType +{ + /// + /// D3D_REGISTER_COMPONENT_UNKNOWN + Unknown = 0, + /// + /// D3D_REGISTER_COMPONENT_UINT32 + UInt32 = 1, + /// + /// D3D_REGISTER_COMPONENT_SINT32 + Sint32 = 2, + /// + /// D3D_REGISTER_COMPONENT_FLOAT32 + Float32 = 3, + /// + /// D3D_REGISTER_COMPONENT_UINT16 + UInt16 = 4, + /// + /// D3D_REGISTER_COMPONENT_SINT16 + Sint16 = 5, + /// + /// D3D_REGISTER_COMPONENT_FLOAT16 + Float16 = 6, + /// + /// D3D_REGISTER_COMPONENT_UINT64 + UInt64 = 7, + /// + /// D3D_REGISTER_COMPONENT_SINT64 + Sint64 = 8, + /// + /// D3D_REGISTER_COMPONENT_FLOAT64 + Float64 = 9, +} + +/// +/// D3D_TESSELLATOR_DOMAIN +public enum TessellatorDomain +{ + /// + /// D3D_TESSELLATOR_DOMAIN_UNDEFINED + Undefined = 0, + /// + /// D3D_TESSELLATOR_DOMAIN_ISOLINE + Isoline = 1, + /// + /// D3D_TESSELLATOR_DOMAIN_TRI + Tri = 2, + /// + /// D3D_TESSELLATOR_DOMAIN_QUAD + Quad = 3, +} + +/// +/// D3D_TESSELLATOR_PARTITIONING +public enum TessellatorPartitioning +{ + /// + /// D3D_TESSELLATOR_PARTITIONING_UNDEFINED + Undefined = 0, + /// + /// D3D_TESSELLATOR_PARTITIONING_INTEGER + Integer = 1, + /// + /// D3D_TESSELLATOR_PARTITIONING_POW2 + Pow2 = 2, + /// + /// D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD + FractionalOdd = 3, + /// + /// D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN + FractionalEven = 4, +} + +/// +/// D3D_TESSELLATOR_OUTPUT_PRIMITIVE +public enum TessellatorOutputPrimitive +{ + /// + /// D3D_TESSELLATOR_OUTPUT_UNDEFINED + Undefined = 0, + /// + /// D3D_TESSELLATOR_OUTPUT_POINT + Point = 1, + /// + /// D3D_TESSELLATOR_OUTPUT_LINE + Line = 2, + /// + /// D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW + TriangleCw = 3, + /// + /// D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW + TriangleCcw = 4, +} + +/// +/// D3D_MIN_PRECISION +public enum MinPrecision +{ + /// + /// D3D_MIN_PRECISION_DEFAULT + Default = 0, + /// + /// D3D_MIN_PRECISION_FLOAT_16 + Float16 = 1, + /// + /// D3D_MIN_PRECISION_FLOAT_2_8 + Float28 = 2, + /// + /// D3D_MIN_PRECISION_RESERVED + Reserved = 3, + /// + /// D3D_MIN_PRECISION_SINT_16 + Sint16 = 4, + /// + /// D3D_MIN_PRECISION_UINT_16 + Uint16 = 5, + /// + /// D3D_MIN_PRECISION_ANY_16 + Any16 = 240, + /// + /// D3D_MIN_PRECISION_ANY_10 + Any10 = 241, +} + +/// +/// D3D_INTERPOLATION_MODE +public enum InterpolationMode +{ + /// + /// D3D_INTERPOLATION_UNDEFINED + Undefined = 0, + /// + /// D3D_INTERPOLATION_CONSTANT + Constant = 1, + /// + /// D3D_INTERPOLATION_LINEAR + Linear = 2, + /// + /// D3D_INTERPOLATION_LINEAR_CENTROID + LinearCentroid = 3, + /// + /// D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE + LinearNoPerspective = 4, + /// + /// D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID + LinearNoPerspectiveCentroid = 5, + /// + /// D3D_INTERPOLATION_LINEAR_SAMPLE + LinearSample = 6, + /// + /// D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE + LinearNoPerspectiveSample = 7, +} + +/// +/// D3D_PARAMETER_FLAGS +[Flags] +public enum ParameterFlags +{ + /// + /// D3D_PF_NONE + None = 0, + /// + /// D3D_PF_IN + In = 1, + /// + /// D3D_PF_OUT + Out = 2, +} + +/// +/// D3D_FORMAT_LAYOUT +public enum FormatLayout +{ + /// + /// D3DFL_STANDARD + D3DFL_STANDARD = 0, + /// + /// D3DFL_CUSTOM + D3DFL_CUSTOM = -1, +} + +/// +/// D3D_FORMAT_TYPE_LEVEL +public enum FormatTypeLevel +{ + /// + /// D3DFTL_NO_TYPE + D3DFTL_NO_TYPE = 0, + /// + /// D3DFTL_PARTIAL_TYPE + D3DFTL_PARTIAL_TYPE = -2, + /// + /// D3DFTL_FULL_TYPE + D3DFTL_FULL_TYPE = -1, +} + +/// +/// D3D_FORMAT_COMPONENT_NAME +public enum FormatComponentName +{ + /// + /// D3DFCN_R + D3DFCN_R = -4, + /// + /// D3DFCN_G + D3DFCN_G = -3, + /// + /// D3DFCN_B + D3DFCN_B = -2, + /// + /// D3DFCN_A + D3DFCN_A = -1, + /// + /// D3DFCN_D + D3DFCN_D = 0, + /// + /// D3DFCN_S + D3DFCN_S = 1, + /// + /// D3DFCN_X + D3DFCN_X = 2, +} + +/// +/// D3D_FORMAT_COMPONENT_INTERPRETATION +public enum FormatComponentInterpretation +{ + /// + /// D3DFCI_TYPELESS + D3DFCI_TYPELESS = 0, + /// + /// D3DFCI_FLOAT + D3DFCI_FLOAT = -4, + /// + /// D3DFCI_SNORM + D3DFCI_SNORM = -3, + /// + /// D3DFCI_UNORM + D3DFCI_UNORM = -2, + /// + /// D3DFCI_SINT + D3DFCI_SINT = -1, + /// + /// D3DFCI_UINT + D3DFCI_UINT = 1, + /// + /// D3DFCI_UNORM_SRGB + D3DFCI_UNORM_SRGB = 2, + /// + /// D3DFCI_BIASED_FIXED_2_8 + D3DFCI_BIASED_FIXED_2_8 = 3, +} diff --git a/Generated/Graphics/Direct3D/Graphics.Direct3D.Structs.cs b/Generated/Graphics/Direct3D/Graphics.Direct3D.Structs.cs new file mode 100644 index 0000000..e10e276 --- /dev/null +++ b/Generated/Graphics/Direct3D/Graphics.Direct3D.Structs.cs @@ -0,0 +1,21 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D; + +/// +/// D3D_SHADER_MACRO +public partial struct ShaderMacro +{ + /// + public unsafe byte* Name; + + /// + public unsafe byte* Definition; +} diff --git a/Generated/Graphics/Direct3D/ID3DBlob.cs b/Generated/Graphics/Direct3D/ID3DBlob.cs new file mode 100644 index 0000000..62e91fd --- /dev/null +++ b/Generated/Graphics/Direct3D/ID3DBlob.cs @@ -0,0 +1,98 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D; + +/// +/// ID3DBlob +[Guid("8ba5fb08-5195-40e2-ac58-0d989c3a0102")] +[NativeTypeName("struct ID3DBlob : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3DBlob : ID3DBlob.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3DBlob + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x08, 0xFB, 0xA5, 0x8B, + 0x95, 0x51, + 0xE2, 0x40, + 0xAC, + 0x58, + 0x0D, + 0x98, + 0x9C, + 0x3A, + 0x01, + 0x02 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DBlob)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3DBlob*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3DBlob*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3DBlob*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void* GetBufferPointer() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3DBlob*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public nuint GetBufferSize() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((ID3DBlob*)Unsafe.AsPointer(ref this)); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + void* GetBufferPointer(); + + [VtblIndex(4)] + nuint GetBufferSize(); + } +} + diff --git a/Generated/Graphics/Direct3D/ID3DDestructionNotifier.cs b/Generated/Graphics/Direct3D/ID3DDestructionNotifier.cs new file mode 100644 index 0000000..e804f46 --- /dev/null +++ b/Generated/Graphics/Direct3D/ID3DDestructionNotifier.cs @@ -0,0 +1,98 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D; + +/// +/// ID3DDestructionNotifier +[Guid("a06eb39a-50da-425b-8c31-4eecd6c270f3")] +[NativeTypeName("struct ID3DDestructionNotifier : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3DDestructionNotifier : ID3DDestructionNotifier.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3DDestructionNotifier + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x9A, 0xB3, 0x6E, 0xA0, + 0xDA, 0x50, + 0x5B, 0x42, + 0x8C, + 0x31, + 0x4E, + 0xEC, + 0xD6, + 0xC2, + 0x70, + 0xF3 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3DDestructionNotifier)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult RegisterDestructionCallback(delegate* unmanaged[Stdcall] callbackFn, void* pData, uint* pCallbackID) + { + return ((delegate* unmanaged[MemberFunction], void*, uint*, int>)(lpVtbl[3]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this), callbackFn, pData, pCallbackID); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult UnregisterDestructionCallback(uint callbackID) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this), callbackID); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + HResult RegisterDestructionCallback(delegate* unmanaged[Stdcall] callbackFn, void* pData, uint* pCallbackID); + + [VtblIndex(4)] + HResult UnregisterDestructionCallback(uint callbackID); + } +} + diff --git a/Generated/Graphics/Direct3D/ID3DInclude.cs b/Generated/Graphics/Direct3D/ID3DInclude.cs new file mode 100644 index 0000000..c75aa2a --- /dev/null +++ b/Generated/Graphics/Direct3D/ID3DInclude.cs @@ -0,0 +1,43 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D; + +/// +/// ID3DInclude +public unsafe partial struct ID3DInclude : ID3DInclude.Interface +{ + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult Open(IncludeType IncludeType, byte* pFileName, void* pParentData, void** ppData, uint* pBytes) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3DInclude*)Unsafe.AsPointer(ref this), IncludeType, pFileName, pParentData, ppData, pBytes); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public HResult Close(void* pData) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3DInclude*)Unsafe.AsPointer(ref this), pData); + } + + public interface Interface + { + [VtblIndex(0)] + HResult Open(IncludeType IncludeType, byte* pFileName, void* pParentData, void** ppData, uint* pBytes); + + [VtblIndex(1)] + HResult Close(void* pData); + } +} + diff --git a/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Apis.cs b/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Apis.cs new file mode 100644 index 0000000..b61fa41 --- /dev/null +++ b/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Apis.cs @@ -0,0 +1,195 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Dxgi.Common; + +public static partial class Apis +{ + public const uint DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN = 4294967295; + + public const uint DXGI_CENTER_MULTISAMPLE_QUALITY_PATTERN = 4294967294; + + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 = ColorSpaceType.RgbFullG22NoneP709; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 = ColorSpaceType.RgbFullG10NoneP709; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709 = ColorSpaceType.RgbStudioG22NoneP709; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020 = ColorSpaceType.RgbStudioG22NoneP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_RESERVED = ColorSpaceType.Reserved; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 = ColorSpaceType.YcbcrFullG22NoneP709X601; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 = ColorSpaceType.YcbcrStudioG22LeftP601; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601 = ColorSpaceType.YcbcrFullG22LeftP601; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 = ColorSpaceType.YcbcrStudioG22LeftP709; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709 = ColorSpaceType.YcbcrFullG22LeftP709; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 = ColorSpaceType.YcbcrStudioG22LeftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 = ColorSpaceType.YcbcrFullG22LeftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 = ColorSpaceType.RgbFullG2084NoneP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020 = ColorSpaceType.YcbcrStudioG2084LeftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020 = ColorSpaceType.RgbStudioG2084NoneP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020 = ColorSpaceType.YcbcrStudioG22TopleftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020 = ColorSpaceType.YcbcrStudioG2084TopleftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020 = ColorSpaceType.RgbFullG22NoneP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020 = ColorSpaceType.YcbcrStudioGhlgTopleftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020 = ColorSpaceType.YcbcrFullGhlgTopleftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709 = ColorSpaceType.RgbStudioG24NoneP709; + public const ColorSpaceType DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020 = ColorSpaceType.RgbStudioG24NoneP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709 = ColorSpaceType.YcbcrStudioG24LeftP709; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020 = ColorSpaceType.YcbcrStudioG24LeftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020 = ColorSpaceType.YcbcrStudioG24TopleftP2020; + public const ColorSpaceType DXGI_COLOR_SPACE_CUSTOM = ColorSpaceType.Custom; + public const Format DXGI_FORMAT_UNKNOWN = Format.Unknown; + public const Format DXGI_FORMAT_R32G32B32A32_TYPELESS = Format.R32G32B32A32Typeless; + public const Format DXGI_FORMAT_R32G32B32A32_FLOAT = Format.R32G32B32A32Float; + public const Format DXGI_FORMAT_R32G32B32A32_UINT = Format.R32G32B32A32Uint; + public const Format DXGI_FORMAT_R32G32B32A32_SINT = Format.R32G32B32A32Sint; + public const Format DXGI_FORMAT_R32G32B32_TYPELESS = Format.R32G32B32Typeless; + public const Format DXGI_FORMAT_R32G32B32_FLOAT = Format.R32G32B32Float; + public const Format DXGI_FORMAT_R32G32B32_UINT = Format.R32G32B32Uint; + public const Format DXGI_FORMAT_R32G32B32_SINT = Format.R32G32B32Sint; + public const Format DXGI_FORMAT_R16G16B16A16_TYPELESS = Format.R16G16B16A16Typeless; + public const Format DXGI_FORMAT_R16G16B16A16_FLOAT = Format.R16G16B16A16Float; + public const Format DXGI_FORMAT_R16G16B16A16_UNORM = Format.R16G16B16A16Unorm; + public const Format DXGI_FORMAT_R16G16B16A16_UINT = Format.R16G16B16A16Uint; + public const Format DXGI_FORMAT_R16G16B16A16_SNORM = Format.R16G16B16A16Snorm; + public const Format DXGI_FORMAT_R16G16B16A16_SINT = Format.R16G16B16A16Sint; + public const Format DXGI_FORMAT_R32G32_TYPELESS = Format.R32G32Typeless; + public const Format DXGI_FORMAT_R32G32_FLOAT = Format.R32G32Float; + public const Format DXGI_FORMAT_R32G32_UINT = Format.R32G32Uint; + public const Format DXGI_FORMAT_R32G32_SINT = Format.R32G32Sint; + public const Format DXGI_FORMAT_R32G8X24_TYPELESS = Format.R32G8X24Typeless; + public const Format DXGI_FORMAT_D32_FLOAT_S8X24_UINT = Format.D32FloatS8X24Uint; + public const Format DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = Format.R32FloatX8X24Typeless; + public const Format DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = Format.X32TypelessG8X24Uint; + public const Format DXGI_FORMAT_R10G10B10A2_TYPELESS = Format.R10G10B10A2Typeless; + public const Format DXGI_FORMAT_R10G10B10A2_UNORM = Format.R10G10B10A2Unorm; + public const Format DXGI_FORMAT_R10G10B10A2_UINT = Format.R10G10B10A2Uint; + public const Format DXGI_FORMAT_R11G11B10_FLOAT = Format.R11G11B10Float; + public const Format DXGI_FORMAT_R8G8B8A8_TYPELESS = Format.R8G8B8A8Typeless; + public const Format DXGI_FORMAT_R8G8B8A8_UNORM = Format.R8G8B8A8Unorm; + public const Format DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = Format.R8G8B8A8UnormSrgb; + public const Format DXGI_FORMAT_R8G8B8A8_UINT = Format.R8G8B8A8Uint; + public const Format DXGI_FORMAT_R8G8B8A8_SNORM = Format.R8G8B8A8Snorm; + public const Format DXGI_FORMAT_R8G8B8A8_SINT = Format.R8G8B8A8Sint; + public const Format DXGI_FORMAT_R16G16_TYPELESS = Format.R16G16Typeless; + public const Format DXGI_FORMAT_R16G16_FLOAT = Format.R16G16Float; + public const Format DXGI_FORMAT_R16G16_UNORM = Format.R16G16Unorm; + public const Format DXGI_FORMAT_R16G16_UINT = Format.R16G16Uint; + public const Format DXGI_FORMAT_R16G16_SNORM = Format.R16G16Snorm; + public const Format DXGI_FORMAT_R16G16_SINT = Format.R16G16Sint; + public const Format DXGI_FORMAT_R32_TYPELESS = Format.R32Typeless; + public const Format DXGI_FORMAT_D32_FLOAT = Format.D32Float; + public const Format DXGI_FORMAT_R32_FLOAT = Format.R32Float; + public const Format DXGI_FORMAT_R32_UINT = Format.R32Uint; + public const Format DXGI_FORMAT_R32_SINT = Format.R32Sint; + public const Format DXGI_FORMAT_R24G8_TYPELESS = Format.R24G8Typeless; + public const Format DXGI_FORMAT_D24_UNORM_S8_UINT = Format.D24UnormS8Uint; + public const Format DXGI_FORMAT_R24_UNORM_X8_TYPELESS = Format.R24UnormX8Typeless; + public const Format DXGI_FORMAT_X24_TYPELESS_G8_UINT = Format.X24TypelessG8Uint; + public const Format DXGI_FORMAT_R8G8_TYPELESS = Format.R8G8Typeless; + public const Format DXGI_FORMAT_R8G8_UNORM = Format.R8G8Unorm; + public const Format DXGI_FORMAT_R8G8_UINT = Format.R8G8Uint; + public const Format DXGI_FORMAT_R8G8_SNORM = Format.R8G8Snorm; + public const Format DXGI_FORMAT_R8G8_SINT = Format.R8G8Sint; + public const Format DXGI_FORMAT_R16_TYPELESS = Format.R16Typeless; + public const Format DXGI_FORMAT_R16_FLOAT = Format.R16Float; + public const Format DXGI_FORMAT_D16_UNORM = Format.D16Unorm; + public const Format DXGI_FORMAT_R16_UNORM = Format.R16Unorm; + public const Format DXGI_FORMAT_R16_UINT = Format.R16Uint; + public const Format DXGI_FORMAT_R16_SNORM = Format.R16Snorm; + public const Format DXGI_FORMAT_R16_SINT = Format.R16Sint; + public const Format DXGI_FORMAT_R8_TYPELESS = Format.R8Typeless; + public const Format DXGI_FORMAT_R8_UNORM = Format.R8Unorm; + public const Format DXGI_FORMAT_R8_UINT = Format.R8Uint; + public const Format DXGI_FORMAT_R8_SNORM = Format.R8Snorm; + public const Format DXGI_FORMAT_R8_SINT = Format.R8Sint; + public const Format DXGI_FORMAT_A8_UNORM = Format.A8Unorm; + public const Format DXGI_FORMAT_R1_UNORM = Format.R1Unorm; + public const Format DXGI_FORMAT_R9G9B9E5_SHAREDEXP = Format.R9G9B9E5SharedExp; + public const Format DXGI_FORMAT_R8G8_B8G8_UNORM = Format.R8G8_B8G8Unorm; + public const Format DXGI_FORMAT_G8R8_G8B8_UNORM = Format.G8R8_G8B8Unorm; + public const Format DXGI_FORMAT_BC1_TYPELESS = Format.BC1Typeless; + public const Format DXGI_FORMAT_BC1_UNORM = Format.BC1Unorm; + public const Format DXGI_FORMAT_BC1_UNORM_SRGB = Format.BC1UnormSrgb; + public const Format DXGI_FORMAT_BC2_TYPELESS = Format.BC2Typeless; + public const Format DXGI_FORMAT_BC2_UNORM = Format.BC2Unorm; + public const Format DXGI_FORMAT_BC2_UNORM_SRGB = Format.BC2UnormSrgb; + public const Format DXGI_FORMAT_BC3_TYPELESS = Format.BC3Typeless; + public const Format DXGI_FORMAT_BC3_UNORM = Format.BC3Unorm; + public const Format DXGI_FORMAT_BC3_UNORM_SRGB = Format.BC3UnormSrgb; + public const Format DXGI_FORMAT_BC4_TYPELESS = Format.BC4Typeless; + public const Format DXGI_FORMAT_BC4_UNORM = Format.BC4Unorm; + public const Format DXGI_FORMAT_BC4_SNORM = Format.BC4Snorm; + public const Format DXGI_FORMAT_BC5_TYPELESS = Format.BC5Typeless; + public const Format DXGI_FORMAT_BC5_UNORM = Format.BC5Unorm; + public const Format DXGI_FORMAT_BC5_SNORM = Format.BC5Snorm; + public const Format DXGI_FORMAT_B5G6R5_UNORM = Format.B5G6R5Unorm; + public const Format DXGI_FORMAT_B5G5R5A1_UNORM = Format.B5G5R5A1Unorm; + public const Format DXGI_FORMAT_B8G8R8A8_UNORM = Format.B8G8R8A8Unorm; + public const Format DXGI_FORMAT_B8G8R8X8_UNORM = Format.B8G8R8X8Unorm; + public const Format DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = Format.R10G10B10XRBiasA2Unorm; + public const Format DXGI_FORMAT_B8G8R8A8_TYPELESS = Format.B8G8R8A8Typeless; + public const Format DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = Format.B8G8R8A8UnormSrgb; + public const Format DXGI_FORMAT_B8G8R8X8_TYPELESS = Format.B8G8R8X8Typeless; + public const Format DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = Format.B8G8R8X8UnormSrgb; + public const Format DXGI_FORMAT_BC6H_TYPELESS = Format.BC6HTypeless; + public const Format DXGI_FORMAT_BC6H_UF16 = Format.BC6HUF16; + public const Format DXGI_FORMAT_BC6H_SF16 = Format.BC6HSF16; + public const Format DXGI_FORMAT_BC7_TYPELESS = Format.BC7Typeless; + public const Format DXGI_FORMAT_BC7_UNORM = Format.BC7Unorm; + public const Format DXGI_FORMAT_BC7_UNORM_SRGB = Format.BC7UnormSrgb; + public const Format DXGI_FORMAT_AYUV = Format.AYUV; + public const Format DXGI_FORMAT_Y410 = Format.Y410; + public const Format DXGI_FORMAT_Y416 = Format.Y416; + public const Format DXGI_FORMAT_NV12 = Format.NV12; + public const Format DXGI_FORMAT_P010 = Format.P010; + public const Format DXGI_FORMAT_P016 = Format.P016; + public const Format DXGI_FORMAT_420_OPAQUE = Format.Opaque420; + public const Format DXGI_FORMAT_YUY2 = Format.YUY2; + public const Format DXGI_FORMAT_Y210 = Format.Y210; + public const Format DXGI_FORMAT_Y216 = Format.Y216; + public const Format DXGI_FORMAT_NV11 = Format.NV11; + public const Format DXGI_FORMAT_AI44 = Format.AI44; + public const Format DXGI_FORMAT_IA44 = Format.IA44; + public const Format DXGI_FORMAT_P8 = Format.P8; + public const Format DXGI_FORMAT_A8P8 = Format.A8P8; + public const Format DXGI_FORMAT_B4G4R4A4_UNORM = Format.B4G4R4A4Unorm; + public const Format DXGI_FORMAT_P208 = Format.P208; + public const Format DXGI_FORMAT_V208 = Format.V208; + public const Format DXGI_FORMAT_V408 = Format.V408; + public const Format DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = Format.SamplerFeedbackMinMipOpaque; + public const Format DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = Format.SamplerFeedbackMipRegionUsedOpaque; + public const Format DXGI_FORMAT_A4B4G4R4_UNORM = Format.A4B4G4R4Unorm; + public const Format DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT = Format.Xbox_R10G10B10_7E3_A2Float; + public const Format DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT = Format.Xbox_R10G10B10_6E4_A2Float; + public const Format DXGI_FORMAT_D16_UNORM_S8_UINT = Format.Xbox_D16Unorm_S8Uint; + public const Format DXGI_FORMAT_R16_UNORM_X8_TYPELESS = Format.Xbox_R16Unorm_X8Typeless; + public const Format DXGI_FORMAT_X16_TYPELESS_G8_UINT = Format.Xbox_X16Typeless_G8Uint; + public const Format DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM = Format.Xbox_R10G10B10Snorm_A2Unorm; + public const Format DXGI_FORMAT_R4G4_UNORM = Format.Xbox_R4G4Unorm; + public const ModeScanlineOrder DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED = ModeScanlineOrder.Unspecified; + public const ModeScanlineOrder DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE = ModeScanlineOrder.Progressive; + public const ModeScanlineOrder DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST = ModeScanlineOrder.UpperFieldFirst; + public const ModeScanlineOrder DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST = ModeScanlineOrder.LowerFieldFirst; + public const ModeScaling DXGI_MODE_SCALING_UNSPECIFIED = ModeScaling.Unspecified; + public const ModeScaling DXGI_MODE_SCALING_CENTERED = ModeScaling.Centered; + public const ModeScaling DXGI_MODE_SCALING_STRETCHED = ModeScaling.Stretched; + public const ModeRotation DXGI_MODE_ROTATION_UNSPECIFIED = ModeRotation.Unspecified; + public const ModeRotation DXGI_MODE_ROTATION_IDENTITY = ModeRotation.Identity; + public const ModeRotation DXGI_MODE_ROTATION_ROTATE90 = ModeRotation.Rotate90; + public const ModeRotation DXGI_MODE_ROTATION_ROTATE180 = ModeRotation.Rotate180; + public const ModeRotation DXGI_MODE_ROTATION_ROTATE270 = ModeRotation.Rotate270; + public const AlphaMode DXGI_ALPHA_MODE_UNSPECIFIED = AlphaMode.Unspecified; + public const AlphaMode DXGI_ALPHA_MODE_PREMULTIPLIED = AlphaMode.Premultiplied; + public const AlphaMode DXGI_ALPHA_MODE_STRAIGHT = AlphaMode.Straight; + public const AlphaMode DXGI_ALPHA_MODE_IGNORE = AlphaMode.Ignore; + public const CpuAccess DXGI_CPU_ACCESS_NONE = CpuAccess.None; + public const CpuAccess DXGI_CPU_ACCESS_DYNAMIC = CpuAccess.Dynamic; + public const CpuAccess DXGI_CPU_ACCESS_READ_WRITE = CpuAccess.ReadWrite; + public const CpuAccess DXGI_CPU_ACCESS_SCRATCH = CpuAccess.Scratch; + public const CpuAccess DXGI_CPU_ACCESS_FIELD = CpuAccess.Field; +} + diff --git a/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Enums.cs b/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Enums.cs new file mode 100644 index 0000000..a63b273 --- /dev/null +++ b/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Enums.cs @@ -0,0 +1,566 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Dxgi.Common; + +/// +/// DXGI_COLOR_SPACE_TYPE +public enum ColorSpaceType +{ + /// + /// DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 + RgbFullG22NoneP709 = 0, + /// + /// DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 + RgbFullG10NoneP709 = 1, + /// + /// DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709 + RgbStudioG22NoneP709 = 2, + /// + /// DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020 + RgbStudioG22NoneP2020 = 3, + /// + /// DXGI_COLOR_SPACE_RESERVED + Reserved = 4, + /// + /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 + YcbcrFullG22NoneP709X601 = 5, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + YcbcrStudioG22LeftP601 = 6, + /// + /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601 + YcbcrFullG22LeftP601 = 7, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + YcbcrStudioG22LeftP709 = 8, + /// + /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709 + YcbcrFullG22LeftP709 = 9, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 + YcbcrStudioG22LeftP2020 = 10, + /// + /// DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 + YcbcrFullG22LeftP2020 = 11, + /// + /// DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 + RgbFullG2084NoneP2020 = 12, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020 + YcbcrStudioG2084LeftP2020 = 13, + /// + /// DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020 + RgbStudioG2084NoneP2020 = 14, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020 + YcbcrStudioG22TopleftP2020 = 15, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020 + YcbcrStudioG2084TopleftP2020 = 16, + /// + /// DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020 + RgbFullG22NoneP2020 = 17, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020 + YcbcrStudioGhlgTopleftP2020 = 18, + /// + /// DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020 + YcbcrFullGhlgTopleftP2020 = 19, + /// + /// DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P709 + RgbStudioG24NoneP709 = 20, + /// + /// DXGI_COLOR_SPACE_RGB_STUDIO_G24_NONE_P2020 + RgbStudioG24NoneP2020 = 21, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P709 + YcbcrStudioG24LeftP709 = 22, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_LEFT_P2020 + YcbcrStudioG24LeftP2020 = 23, + /// + /// DXGI_COLOR_SPACE_YCBCR_STUDIO_G24_TOPLEFT_P2020 + YcbcrStudioG24TopleftP2020 = 24, + /// + /// DXGI_COLOR_SPACE_CUSTOM + Custom = -1, +} + +/// +/// DXGI_FORMAT +public enum Format : uint +{ + /// + /// DXGI_FORMAT_UNKNOWN + Unknown = 0, + /// + /// DXGI_FORMAT_R32G32B32A32_TYPELESS + R32G32B32A32Typeless = 1, + /// + /// DXGI_FORMAT_R32G32B32A32_FLOAT + R32G32B32A32Float = 2, + /// + /// DXGI_FORMAT_R32G32B32A32_UINT + R32G32B32A32Uint = 3, + /// + /// DXGI_FORMAT_R32G32B32A32_SINT + R32G32B32A32Sint = 4, + /// + /// DXGI_FORMAT_R32G32B32_TYPELESS + R32G32B32Typeless = 5, + /// + /// DXGI_FORMAT_R32G32B32_FLOAT + R32G32B32Float = 6, + /// + /// DXGI_FORMAT_R32G32B32_UINT + R32G32B32Uint = 7, + /// + /// DXGI_FORMAT_R32G32B32_SINT + R32G32B32Sint = 8, + /// + /// DXGI_FORMAT_R16G16B16A16_TYPELESS + R16G16B16A16Typeless = 9, + /// + /// DXGI_FORMAT_R16G16B16A16_FLOAT + R16G16B16A16Float = 10, + /// + /// DXGI_FORMAT_R16G16B16A16_UNORM + R16G16B16A16Unorm = 11, + /// + /// DXGI_FORMAT_R16G16B16A16_UINT + R16G16B16A16Uint = 12, + /// + /// DXGI_FORMAT_R16G16B16A16_SNORM + R16G16B16A16Snorm = 13, + /// + /// DXGI_FORMAT_R16G16B16A16_SINT + R16G16B16A16Sint = 14, + /// + /// DXGI_FORMAT_R32G32_TYPELESS + R32G32Typeless = 15, + /// + /// DXGI_FORMAT_R32G32_FLOAT + R32G32Float = 16, + /// + /// DXGI_FORMAT_R32G32_UINT + R32G32Uint = 17, + /// + /// DXGI_FORMAT_R32G32_SINT + R32G32Sint = 18, + /// + /// DXGI_FORMAT_R32G8X24_TYPELESS + R32G8X24Typeless = 19, + /// + /// DXGI_FORMAT_D32_FLOAT_S8X24_UINT + D32FloatS8X24Uint = 20, + /// + /// DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS + R32FloatX8X24Typeless = 21, + /// + /// DXGI_FORMAT_X32_TYPELESS_G8X24_UINT + X32TypelessG8X24Uint = 22, + /// + /// DXGI_FORMAT_R10G10B10A2_TYPELESS + R10G10B10A2Typeless = 23, + /// + /// DXGI_FORMAT_R10G10B10A2_UNORM + R10G10B10A2Unorm = 24, + /// + /// DXGI_FORMAT_R10G10B10A2_UINT + R10G10B10A2Uint = 25, + /// + /// DXGI_FORMAT_R11G11B10_FLOAT + R11G11B10Float = 26, + /// + /// DXGI_FORMAT_R8G8B8A8_TYPELESS + R8G8B8A8Typeless = 27, + /// + /// DXGI_FORMAT_R8G8B8A8_UNORM + R8G8B8A8Unorm = 28, + /// + /// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB + R8G8B8A8UnormSrgb = 29, + /// + /// DXGI_FORMAT_R8G8B8A8_UINT + R8G8B8A8Uint = 30, + /// + /// DXGI_FORMAT_R8G8B8A8_SNORM + R8G8B8A8Snorm = 31, + /// + /// DXGI_FORMAT_R8G8B8A8_SINT + R8G8B8A8Sint = 32, + /// + /// DXGI_FORMAT_R16G16_TYPELESS + R16G16Typeless = 33, + /// + /// DXGI_FORMAT_R16G16_FLOAT + R16G16Float = 34, + /// + /// DXGI_FORMAT_R16G16_UNORM + R16G16Unorm = 35, + /// + /// DXGI_FORMAT_R16G16_UINT + R16G16Uint = 36, + /// + /// DXGI_FORMAT_R16G16_SNORM + R16G16Snorm = 37, + /// + /// DXGI_FORMAT_R16G16_SINT + R16G16Sint = 38, + /// + /// DXGI_FORMAT_R32_TYPELESS + R32Typeless = 39, + /// + /// DXGI_FORMAT_D32_FLOAT + D32Float = 40, + /// + /// DXGI_FORMAT_R32_FLOAT + R32Float = 41, + /// + /// DXGI_FORMAT_R32_UINT + R32Uint = 42, + /// + /// DXGI_FORMAT_R32_SINT + R32Sint = 43, + /// + /// DXGI_FORMAT_R24G8_TYPELESS + R24G8Typeless = 44, + /// + /// DXGI_FORMAT_D24_UNORM_S8_UINT + D24UnormS8Uint = 45, + /// + /// DXGI_FORMAT_R24_UNORM_X8_TYPELESS + R24UnormX8Typeless = 46, + /// + /// DXGI_FORMAT_X24_TYPELESS_G8_UINT + X24TypelessG8Uint = 47, + /// + /// DXGI_FORMAT_R8G8_TYPELESS + R8G8Typeless = 48, + /// + /// DXGI_FORMAT_R8G8_UNORM + R8G8Unorm = 49, + /// + /// DXGI_FORMAT_R8G8_UINT + R8G8Uint = 50, + /// + /// DXGI_FORMAT_R8G8_SNORM + R8G8Snorm = 51, + /// + /// DXGI_FORMAT_R8G8_SINT + R8G8Sint = 52, + /// + /// DXGI_FORMAT_R16_TYPELESS + R16Typeless = 53, + /// + /// DXGI_FORMAT_R16_FLOAT + R16Float = 54, + /// + /// DXGI_FORMAT_D16_UNORM + D16Unorm = 55, + /// + /// DXGI_FORMAT_R16_UNORM + R16Unorm = 56, + /// + /// DXGI_FORMAT_R16_UINT + R16Uint = 57, + /// + /// DXGI_FORMAT_R16_SNORM + R16Snorm = 58, + /// + /// DXGI_FORMAT_R16_SINT + R16Sint = 59, + /// + /// DXGI_FORMAT_R8_TYPELESS + R8Typeless = 60, + /// + /// DXGI_FORMAT_R8_UNORM + R8Unorm = 61, + /// + /// DXGI_FORMAT_R8_UINT + R8Uint = 62, + /// + /// DXGI_FORMAT_R8_SNORM + R8Snorm = 63, + /// + /// DXGI_FORMAT_R8_SINT + R8Sint = 64, + /// + /// DXGI_FORMAT_A8_UNORM + A8Unorm = 65, + /// + /// DXGI_FORMAT_R1_UNORM + R1Unorm = 66, + /// + /// DXGI_FORMAT_R9G9B9E5_SHAREDEXP + R9G9B9E5SharedExp = 67, + /// + /// DXGI_FORMAT_R8G8_B8G8_UNORM + R8G8_B8G8Unorm = 68, + /// + /// DXGI_FORMAT_G8R8_G8B8_UNORM + G8R8_G8B8Unorm = 69, + /// + /// DXGI_FORMAT_BC1_TYPELESS + BC1Typeless = 70, + /// + /// DXGI_FORMAT_BC1_UNORM + BC1Unorm = 71, + /// + /// DXGI_FORMAT_BC1_UNORM_SRGB + BC1UnormSrgb = 72, + /// + /// DXGI_FORMAT_BC2_TYPELESS + BC2Typeless = 73, + /// + /// DXGI_FORMAT_BC2_UNORM + BC2Unorm = 74, + /// + /// DXGI_FORMAT_BC2_UNORM_SRGB + BC2UnormSrgb = 75, + /// + /// DXGI_FORMAT_BC3_TYPELESS + BC3Typeless = 76, + /// + /// DXGI_FORMAT_BC3_UNORM + BC3Unorm = 77, + /// + /// DXGI_FORMAT_BC3_UNORM_SRGB + BC3UnormSrgb = 78, + /// + /// DXGI_FORMAT_BC4_TYPELESS + BC4Typeless = 79, + /// + /// DXGI_FORMAT_BC4_UNORM + BC4Unorm = 80, + /// + /// DXGI_FORMAT_BC4_SNORM + BC4Snorm = 81, + /// + /// DXGI_FORMAT_BC5_TYPELESS + BC5Typeless = 82, + /// + /// DXGI_FORMAT_BC5_UNORM + BC5Unorm = 83, + /// + /// DXGI_FORMAT_BC5_SNORM + BC5Snorm = 84, + /// + /// DXGI_FORMAT_B5G6R5_UNORM + B5G6R5Unorm = 85, + /// + /// DXGI_FORMAT_B5G5R5A1_UNORM + B5G5R5A1Unorm = 86, + /// + /// DXGI_FORMAT_B8G8R8A8_UNORM + B8G8R8A8Unorm = 87, + /// + /// DXGI_FORMAT_B8G8R8X8_UNORM + B8G8R8X8Unorm = 88, + /// + /// DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM + R10G10B10XRBiasA2Unorm = 89, + /// + /// DXGI_FORMAT_B8G8R8A8_TYPELESS + B8G8R8A8Typeless = 90, + /// + /// DXGI_FORMAT_B8G8R8A8_UNORM_SRGB + B8G8R8A8UnormSrgb = 91, + /// + /// DXGI_FORMAT_B8G8R8X8_TYPELESS + B8G8R8X8Typeless = 92, + /// + /// DXGI_FORMAT_B8G8R8X8_UNORM_SRGB + B8G8R8X8UnormSrgb = 93, + /// + /// DXGI_FORMAT_BC6H_TYPELESS + BC6HTypeless = 94, + /// + /// DXGI_FORMAT_BC6H_UF16 + BC6HUF16 = 95, + /// + /// DXGI_FORMAT_BC6H_SF16 + BC6HSF16 = 96, + /// + /// DXGI_FORMAT_BC7_TYPELESS + BC7Typeless = 97, + /// + /// DXGI_FORMAT_BC7_UNORM + BC7Unorm = 98, + /// + /// DXGI_FORMAT_BC7_UNORM_SRGB + BC7UnormSrgb = 99, + /// + /// DXGI_FORMAT_AYUV + AYUV = 100, + /// + /// DXGI_FORMAT_Y410 + Y410 = 101, + /// + /// DXGI_FORMAT_Y416 + Y416 = 102, + /// + /// DXGI_FORMAT_NV12 + NV12 = 103, + /// + /// DXGI_FORMAT_P010 + P010 = 104, + /// + /// DXGI_FORMAT_P016 + P016 = 105, + /// + /// DXGI_FORMAT_420_OPAQUE + Opaque420 = 106, + /// + /// DXGI_FORMAT_YUY2 + YUY2 = 107, + /// + /// DXGI_FORMAT_Y210 + Y210 = 108, + /// + /// DXGI_FORMAT_Y216 + Y216 = 109, + /// + /// DXGI_FORMAT_NV11 + NV11 = 110, + /// + /// DXGI_FORMAT_AI44 + AI44 = 111, + /// + /// DXGI_FORMAT_IA44 + IA44 = 112, + /// + /// DXGI_FORMAT_P8 + P8 = 113, + /// + /// DXGI_FORMAT_A8P8 + A8P8 = 114, + /// + /// DXGI_FORMAT_B4G4R4A4_UNORM + B4G4R4A4Unorm = 115, + /// + /// DXGI_FORMAT_P208 + P208 = 130, + /// + /// DXGI_FORMAT_V208 + V208 = 131, + /// + /// DXGI_FORMAT_V408 + V408 = 132, + /// + /// DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE + SamplerFeedbackMinMipOpaque = 189, + /// + /// DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE + SamplerFeedbackMipRegionUsedOpaque = 190, + /// + /// DXGI_FORMAT_A4B4G4R4_UNORM + A4B4G4R4Unorm = 191, + /// DXGI_FORMAT_R10G10B10_7E3_A2_FLOAT + Xbox_R10G10B10_7E3_A2Float = 116u, + /// DXGI_FORMAT_R10G10B10_6E4_A2_FLOAT + Xbox_R10G10B10_6E4_A2Float = 117u, + /// DXGI_FORMAT_D16_UNORM_S8_UINT + Xbox_D16Unorm_S8Uint = 118u, + /// DXGI_FORMAT_R16_UNORM_X8_TYPELESS + Xbox_R16Unorm_X8Typeless = 119u, + /// DXGI_FORMAT_X16_TYPELESS_G8_UINT + Xbox_X16Typeless_G8Uint = 120u, + /// DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM + Xbox_R10G10B10Snorm_A2Unorm = 189u, + /// DXGI_FORMAT_R4G4_UNORM + Xbox_R4G4Unorm = 190u, +} + +/// +/// DXGI_MODE_SCANLINE_ORDER +public enum ModeScanlineOrder +{ + /// + /// DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED + Unspecified = 0, + /// + /// DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE + Progressive = 1, + /// + /// DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST + UpperFieldFirst = 2, + /// + /// DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST + LowerFieldFirst = 3, +} + +/// +/// DXGI_MODE_SCALING +public enum ModeScaling +{ + /// + /// DXGI_MODE_SCALING_UNSPECIFIED + Unspecified = 0, + /// + /// DXGI_MODE_SCALING_CENTERED + Centered = 1, + /// + /// DXGI_MODE_SCALING_STRETCHED + Stretched = 2, +} + +/// +/// DXGI_MODE_ROTATION +public enum ModeRotation +{ + /// + /// DXGI_MODE_ROTATION_UNSPECIFIED + Unspecified = 0, + /// + /// DXGI_MODE_ROTATION_IDENTITY + Identity = 1, + /// + /// DXGI_MODE_ROTATION_ROTATE90 + Rotate90 = 2, + /// + /// DXGI_MODE_ROTATION_ROTATE180 + Rotate180 = 3, + /// + /// DXGI_MODE_ROTATION_ROTATE270 + Rotate270 = 4, +} + +/// +/// DXGI_ALPHA_MODE +public enum AlphaMode +{ + /// + /// DXGI_ALPHA_MODE_UNSPECIFIED + Unspecified = 0, + /// + /// DXGI_ALPHA_MODE_PREMULTIPLIED + Premultiplied = 1, + /// + /// DXGI_ALPHA_MODE_STRAIGHT + Straight = 2, + /// + /// DXGI_ALPHA_MODE_IGNORE + Ignore = 3, +} +/// DXGI_CPU_ACCESS +public enum CpuAccess : uint +{ + /// DXGI_CPU_ACCESS_NONE + None = 0, + /// DXGI_CPU_ACCESS_DYNAMIC + Dynamic = 1, + /// DXGI_CPU_ACCESS_READ_WRITE + ReadWrite = 2, + /// DXGI_CPU_ACCESS_SCRATCH + Scratch = 3, + /// DXGI_CPU_ACCESS_FIELD + Field = 15, +} diff --git a/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Structs.cs b/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Structs.cs new file mode 100644 index 0000000..b950f3a --- /dev/null +++ b/Generated/Graphics/Dxgi.Common/Graphics.Dxgi.Common.Structs.cs @@ -0,0 +1,1179 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Dxgi.Common; + +/// +/// DXGI_RATIONAL +public partial struct Rational +{ + /// + public uint Numerator; + + /// + public uint Denominator; +} + +/// +/// DXGI_SAMPLE_DESC +public partial struct SampleDescription +{ + /// + public uint Count; + + /// + public uint Quality; +} + +/// +/// DXGI_RGB +public partial struct Rgb +{ + /// + public float Red; + + /// + public float Green; + + /// + public float Blue; +} + +/// +/// DXGI_GAMMA_CONTROL +public partial struct GammaControl +{ + /// + public Rgb Scale; + + /// + public Rgb Offset; + + /// + public GammaCurve__FixedBuffer GammaCurve; + + public unsafe struct GammaCurve__FixedBuffer + { + public Rgb e0; + public Rgb e1; + public Rgb e2; + public Rgb e3; + public Rgb e4; + public Rgb e5; + public Rgb e6; + public Rgb e7; + public Rgb e8; + public Rgb e9; + public Rgb e10; + public Rgb e11; + public Rgb e12; + public Rgb e13; + public Rgb e14; + public Rgb e15; + public Rgb e16; + public Rgb e17; + public Rgb e18; + public Rgb e19; + public Rgb e20; + public Rgb e21; + public Rgb e22; + public Rgb e23; + public Rgb e24; + public Rgb e25; + public Rgb e26; + public Rgb e27; + public Rgb e28; + public Rgb e29; + public Rgb e30; + public Rgb e31; + public Rgb e32; + public Rgb e33; + public Rgb e34; + public Rgb e35; + public Rgb e36; + public Rgb e37; + public Rgb e38; + public Rgb e39; + public Rgb e40; + public Rgb e41; + public Rgb e42; + public Rgb e43; + public Rgb e44; + public Rgb e45; + public Rgb e46; + public Rgb e47; + public Rgb e48; + public Rgb e49; + public Rgb e50; + public Rgb e51; + public Rgb e52; + public Rgb e53; + public Rgb e54; + public Rgb e55; + public Rgb e56; + public Rgb e57; + public Rgb e58; + public Rgb e59; + public Rgb e60; + public Rgb e61; + public Rgb e62; + public Rgb e63; + public Rgb e64; + public Rgb e65; + public Rgb e66; + public Rgb e67; + public Rgb e68; + public Rgb e69; + public Rgb e70; + public Rgb e71; + public Rgb e72; + public Rgb e73; + public Rgb e74; + public Rgb e75; + public Rgb e76; + public Rgb e77; + public Rgb e78; + public Rgb e79; + public Rgb e80; + public Rgb e81; + public Rgb e82; + public Rgb e83; + public Rgb e84; + public Rgb e85; + public Rgb e86; + public Rgb e87; + public Rgb e88; + public Rgb e89; + public Rgb e90; + public Rgb e91; + public Rgb e92; + public Rgb e93; + public Rgb e94; + public Rgb e95; + public Rgb e96; + public Rgb e97; + public Rgb e98; + public Rgb e99; + public Rgb e100; + public Rgb e101; + public Rgb e102; + public Rgb e103; + public Rgb e104; + public Rgb e105; + public Rgb e106; + public Rgb e107; + public Rgb e108; + public Rgb e109; + public Rgb e110; + public Rgb e111; + public Rgb e112; + public Rgb e113; + public Rgb e114; + public Rgb e115; + public Rgb e116; + public Rgb e117; + public Rgb e118; + public Rgb e119; + public Rgb e120; + public Rgb e121; + public Rgb e122; + public Rgb e123; + public Rgb e124; + public Rgb e125; + public Rgb e126; + public Rgb e127; + public Rgb e128; + public Rgb e129; + public Rgb e130; + public Rgb e131; + public Rgb e132; + public Rgb e133; + public Rgb e134; + public Rgb e135; + public Rgb e136; + public Rgb e137; + public Rgb e138; + public Rgb e139; + public Rgb e140; + public Rgb e141; + public Rgb e142; + public Rgb e143; + public Rgb e144; + public Rgb e145; + public Rgb e146; + public Rgb e147; + public Rgb e148; + public Rgb e149; + public Rgb e150; + public Rgb e151; + public Rgb e152; + public Rgb e153; + public Rgb e154; + public Rgb e155; + public Rgb e156; + public Rgb e157; + public Rgb e158; + public Rgb e159; + public Rgb e160; + public Rgb e161; + public Rgb e162; + public Rgb e163; + public Rgb e164; + public Rgb e165; + public Rgb e166; + public Rgb e167; + public Rgb e168; + public Rgb e169; + public Rgb e170; + public Rgb e171; + public Rgb e172; + public Rgb e173; + public Rgb e174; + public Rgb e175; + public Rgb e176; + public Rgb e177; + public Rgb e178; + public Rgb e179; + public Rgb e180; + public Rgb e181; + public Rgb e182; + public Rgb e183; + public Rgb e184; + public Rgb e185; + public Rgb e186; + public Rgb e187; + public Rgb e188; + public Rgb e189; + public Rgb e190; + public Rgb e191; + public Rgb e192; + public Rgb e193; + public Rgb e194; + public Rgb e195; + public Rgb e196; + public Rgb e197; + public Rgb e198; + public Rgb e199; + public Rgb e200; + public Rgb e201; + public Rgb e202; + public Rgb e203; + public Rgb e204; + public Rgb e205; + public Rgb e206; + public Rgb e207; + public Rgb e208; + public Rgb e209; + public Rgb e210; + public Rgb e211; + public Rgb e212; + public Rgb e213; + public Rgb e214; + public Rgb e215; + public Rgb e216; + public Rgb e217; + public Rgb e218; + public Rgb e219; + public Rgb e220; + public Rgb e221; + public Rgb e222; + public Rgb e223; + public Rgb e224; + public Rgb e225; + public Rgb e226; + public Rgb e227; + public Rgb e228; + public Rgb e229; + public Rgb e230; + public Rgb e231; + public Rgb e232; + public Rgb e233; + public Rgb e234; + public Rgb e235; + public Rgb e236; + public Rgb e237; + public Rgb e238; + public Rgb e239; + public Rgb e240; + public Rgb e241; + public Rgb e242; + public Rgb e243; + public Rgb e244; + public Rgb e245; + public Rgb e246; + public Rgb e247; + public Rgb e248; + public Rgb e249; + public Rgb e250; + public Rgb e251; + public Rgb e252; + public Rgb e253; + public Rgb e254; + public Rgb e255; + public Rgb e256; + public Rgb e257; + public Rgb e258; + public Rgb e259; + public Rgb e260; + public Rgb e261; + public Rgb e262; + public Rgb e263; + public Rgb e264; + public Rgb e265; + public Rgb e266; + public Rgb e267; + public Rgb e268; + public Rgb e269; + public Rgb e270; + public Rgb e271; + public Rgb e272; + public Rgb e273; + public Rgb e274; + public Rgb e275; + public Rgb e276; + public Rgb e277; + public Rgb e278; + public Rgb e279; + public Rgb e280; + public Rgb e281; + public Rgb e282; + public Rgb e283; + public Rgb e284; + public Rgb e285; + public Rgb e286; + public Rgb e287; + public Rgb e288; + public Rgb e289; + public Rgb e290; + public Rgb e291; + public Rgb e292; + public Rgb e293; + public Rgb e294; + public Rgb e295; + public Rgb e296; + public Rgb e297; + public Rgb e298; + public Rgb e299; + public Rgb e300; + public Rgb e301; + public Rgb e302; + public Rgb e303; + public Rgb e304; + public Rgb e305; + public Rgb e306; + public Rgb e307; + public Rgb e308; + public Rgb e309; + public Rgb e310; + public Rgb e311; + public Rgb e312; + public Rgb e313; + public Rgb e314; + public Rgb e315; + public Rgb e316; + public Rgb e317; + public Rgb e318; + public Rgb e319; + public Rgb e320; + public Rgb e321; + public Rgb e322; + public Rgb e323; + public Rgb e324; + public Rgb e325; + public Rgb e326; + public Rgb e327; + public Rgb e328; + public Rgb e329; + public Rgb e330; + public Rgb e331; + public Rgb e332; + public Rgb e333; + public Rgb e334; + public Rgb e335; + public Rgb e336; + public Rgb e337; + public Rgb e338; + public Rgb e339; + public Rgb e340; + public Rgb e341; + public Rgb e342; + public Rgb e343; + public Rgb e344; + public Rgb e345; + public Rgb e346; + public Rgb e347; + public Rgb e348; + public Rgb e349; + public Rgb e350; + public Rgb e351; + public Rgb e352; + public Rgb e353; + public Rgb e354; + public Rgb e355; + public Rgb e356; + public Rgb e357; + public Rgb e358; + public Rgb e359; + public Rgb e360; + public Rgb e361; + public Rgb e362; + public Rgb e363; + public Rgb e364; + public Rgb e365; + public Rgb e366; + public Rgb e367; + public Rgb e368; + public Rgb e369; + public Rgb e370; + public Rgb e371; + public Rgb e372; + public Rgb e373; + public Rgb e374; + public Rgb e375; + public Rgb e376; + public Rgb e377; + public Rgb e378; + public Rgb e379; + public Rgb e380; + public Rgb e381; + public Rgb e382; + public Rgb e383; + public Rgb e384; + public Rgb e385; + public Rgb e386; + public Rgb e387; + public Rgb e388; + public Rgb e389; + public Rgb e390; + public Rgb e391; + public Rgb e392; + public Rgb e393; + public Rgb e394; + public Rgb e395; + public Rgb e396; + public Rgb e397; + public Rgb e398; + public Rgb e399; + public Rgb e400; + public Rgb e401; + public Rgb e402; + public Rgb e403; + public Rgb e404; + public Rgb e405; + public Rgb e406; + public Rgb e407; + public Rgb e408; + public Rgb e409; + public Rgb e410; + public Rgb e411; + public Rgb e412; + public Rgb e413; + public Rgb e414; + public Rgb e415; + public Rgb e416; + public Rgb e417; + public Rgb e418; + public Rgb e419; + public Rgb e420; + public Rgb e421; + public Rgb e422; + public Rgb e423; + public Rgb e424; + public Rgb e425; + public Rgb e426; + public Rgb e427; + public Rgb e428; + public Rgb e429; + public Rgb e430; + public Rgb e431; + public Rgb e432; + public Rgb e433; + public Rgb e434; + public Rgb e435; + public Rgb e436; + public Rgb e437; + public Rgb e438; + public Rgb e439; + public Rgb e440; + public Rgb e441; + public Rgb e442; + public Rgb e443; + public Rgb e444; + public Rgb e445; + public Rgb e446; + public Rgb e447; + public Rgb e448; + public Rgb e449; + public Rgb e450; + public Rgb e451; + public Rgb e452; + public Rgb e453; + public Rgb e454; + public Rgb e455; + public Rgb e456; + public Rgb e457; + public Rgb e458; + public Rgb e459; + public Rgb e460; + public Rgb e461; + public Rgb e462; + public Rgb e463; + public Rgb e464; + public Rgb e465; + public Rgb e466; + public Rgb e467; + public Rgb e468; + public Rgb e469; + public Rgb e470; + public Rgb e471; + public Rgb e472; + public Rgb e473; + public Rgb e474; + public Rgb e475; + public Rgb e476; + public Rgb e477; + public Rgb e478; + public Rgb e479; + public Rgb e480; + public Rgb e481; + public Rgb e482; + public Rgb e483; + public Rgb e484; + public Rgb e485; + public Rgb e486; + public Rgb e487; + public Rgb e488; + public Rgb e489; + public Rgb e490; + public Rgb e491; + public Rgb e492; + public Rgb e493; + public Rgb e494; + public Rgb e495; + public Rgb e496; + public Rgb e497; + public Rgb e498; + public Rgb e499; + public Rgb e500; + public Rgb e501; + public Rgb e502; + public Rgb e503; + public Rgb e504; + public Rgb e505; + public Rgb e506; + public Rgb e507; + public Rgb e508; + public Rgb e509; + public Rgb e510; + public Rgb e511; + public Rgb e512; + public Rgb e513; + public Rgb e514; + public Rgb e515; + public Rgb e516; + public Rgb e517; + public Rgb e518; + public Rgb e519; + public Rgb e520; + public Rgb e521; + public Rgb e522; + public Rgb e523; + public Rgb e524; + public Rgb e525; + public Rgb e526; + public Rgb e527; + public Rgb e528; + public Rgb e529; + public Rgb e530; + public Rgb e531; + public Rgb e532; + public Rgb e533; + public Rgb e534; + public Rgb e535; + public Rgb e536; + public Rgb e537; + public Rgb e538; + public Rgb e539; + public Rgb e540; + public Rgb e541; + public Rgb e542; + public Rgb e543; + public Rgb e544; + public Rgb e545; + public Rgb e546; + public Rgb e547; + public Rgb e548; + public Rgb e549; + public Rgb e550; + public Rgb e551; + public Rgb e552; + public Rgb e553; + public Rgb e554; + public Rgb e555; + public Rgb e556; + public Rgb e557; + public Rgb e558; + public Rgb e559; + public Rgb e560; + public Rgb e561; + public Rgb e562; + public Rgb e563; + public Rgb e564; + public Rgb e565; + public Rgb e566; + public Rgb e567; + public Rgb e568; + public Rgb e569; + public Rgb e570; + public Rgb e571; + public Rgb e572; + public Rgb e573; + public Rgb e574; + public Rgb e575; + public Rgb e576; + public Rgb e577; + public Rgb e578; + public Rgb e579; + public Rgb e580; + public Rgb e581; + public Rgb e582; + public Rgb e583; + public Rgb e584; + public Rgb e585; + public Rgb e586; + public Rgb e587; + public Rgb e588; + public Rgb e589; + public Rgb e590; + public Rgb e591; + public Rgb e592; + public Rgb e593; + public Rgb e594; + public Rgb e595; + public Rgb e596; + public Rgb e597; + public Rgb e598; + public Rgb e599; + public Rgb e600; + public Rgb e601; + public Rgb e602; + public Rgb e603; + public Rgb e604; + public Rgb e605; + public Rgb e606; + public Rgb e607; + public Rgb e608; + public Rgb e609; + public Rgb e610; + public Rgb e611; + public Rgb e612; + public Rgb e613; + public Rgb e614; + public Rgb e615; + public Rgb e616; + public Rgb e617; + public Rgb e618; + public Rgb e619; + public Rgb e620; + public Rgb e621; + public Rgb e622; + public Rgb e623; + public Rgb e624; + public Rgb e625; + public Rgb e626; + public Rgb e627; + public Rgb e628; + public Rgb e629; + public Rgb e630; + public Rgb e631; + public Rgb e632; + public Rgb e633; + public Rgb e634; + public Rgb e635; + public Rgb e636; + public Rgb e637; + public Rgb e638; + public Rgb e639; + public Rgb e640; + public Rgb e641; + public Rgb e642; + public Rgb e643; + public Rgb e644; + public Rgb e645; + public Rgb e646; + public Rgb e647; + public Rgb e648; + public Rgb e649; + public Rgb e650; + public Rgb e651; + public Rgb e652; + public Rgb e653; + public Rgb e654; + public Rgb e655; + public Rgb e656; + public Rgb e657; + public Rgb e658; + public Rgb e659; + public Rgb e660; + public Rgb e661; + public Rgb e662; + public Rgb e663; + public Rgb e664; + public Rgb e665; + public Rgb e666; + public Rgb e667; + public Rgb e668; + public Rgb e669; + public Rgb e670; + public Rgb e671; + public Rgb e672; + public Rgb e673; + public Rgb e674; + public Rgb e675; + public Rgb e676; + public Rgb e677; + public Rgb e678; + public Rgb e679; + public Rgb e680; + public Rgb e681; + public Rgb e682; + public Rgb e683; + public Rgb e684; + public Rgb e685; + public Rgb e686; + public Rgb e687; + public Rgb e688; + public Rgb e689; + public Rgb e690; + public Rgb e691; + public Rgb e692; + public Rgb e693; + public Rgb e694; + public Rgb e695; + public Rgb e696; + public Rgb e697; + public Rgb e698; + public Rgb e699; + public Rgb e700; + public Rgb e701; + public Rgb e702; + public Rgb e703; + public Rgb e704; + public Rgb e705; + public Rgb e706; + public Rgb e707; + public Rgb e708; + public Rgb e709; + public Rgb e710; + public Rgb e711; + public Rgb e712; + public Rgb e713; + public Rgb e714; + public Rgb e715; + public Rgb e716; + public Rgb e717; + public Rgb e718; + public Rgb e719; + public Rgb e720; + public Rgb e721; + public Rgb e722; + public Rgb e723; + public Rgb e724; + public Rgb e725; + public Rgb e726; + public Rgb e727; + public Rgb e728; + public Rgb e729; + public Rgb e730; + public Rgb e731; + public Rgb e732; + public Rgb e733; + public Rgb e734; + public Rgb e735; + public Rgb e736; + public Rgb e737; + public Rgb e738; + public Rgb e739; + public Rgb e740; + public Rgb e741; + public Rgb e742; + public Rgb e743; + public Rgb e744; + public Rgb e745; + public Rgb e746; + public Rgb e747; + public Rgb e748; + public Rgb e749; + public Rgb e750; + public Rgb e751; + public Rgb e752; + public Rgb e753; + public Rgb e754; + public Rgb e755; + public Rgb e756; + public Rgb e757; + public Rgb e758; + public Rgb e759; + public Rgb e760; + public Rgb e761; + public Rgb e762; + public Rgb e763; + public Rgb e764; + public Rgb e765; + public Rgb e766; + public Rgb e767; + public Rgb e768; + public Rgb e769; + public Rgb e770; + public Rgb e771; + public Rgb e772; + public Rgb e773; + public Rgb e774; + public Rgb e775; + public Rgb e776; + public Rgb e777; + public Rgb e778; + public Rgb e779; + public Rgb e780; + public Rgb e781; + public Rgb e782; + public Rgb e783; + public Rgb e784; + public Rgb e785; + public Rgb e786; + public Rgb e787; + public Rgb e788; + public Rgb e789; + public Rgb e790; + public Rgb e791; + public Rgb e792; + public Rgb e793; + public Rgb e794; + public Rgb e795; + public Rgb e796; + public Rgb e797; + public Rgb e798; + public Rgb e799; + public Rgb e800; + public Rgb e801; + public Rgb e802; + public Rgb e803; + public Rgb e804; + public Rgb e805; + public Rgb e806; + public Rgb e807; + public Rgb e808; + public Rgb e809; + public Rgb e810; + public Rgb e811; + public Rgb e812; + public Rgb e813; + public Rgb e814; + public Rgb e815; + public Rgb e816; + public Rgb e817; + public Rgb e818; + public Rgb e819; + public Rgb e820; + public Rgb e821; + public Rgb e822; + public Rgb e823; + public Rgb e824; + public Rgb e825; + public Rgb e826; + public Rgb e827; + public Rgb e828; + public Rgb e829; + public Rgb e830; + public Rgb e831; + public Rgb e832; + public Rgb e833; + public Rgb e834; + public Rgb e835; + public Rgb e836; + public Rgb e837; + public Rgb e838; + public Rgb e839; + public Rgb e840; + public Rgb e841; + public Rgb e842; + public Rgb e843; + public Rgb e844; + public Rgb e845; + public Rgb e846; + public Rgb e847; + public Rgb e848; + public Rgb e849; + public Rgb e850; + public Rgb e851; + public Rgb e852; + public Rgb e853; + public Rgb e854; + public Rgb e855; + public Rgb e856; + public Rgb e857; + public Rgb e858; + public Rgb e859; + public Rgb e860; + public Rgb e861; + public Rgb e862; + public Rgb e863; + public Rgb e864; + public Rgb e865; + public Rgb e866; + public Rgb e867; + public Rgb e868; + public Rgb e869; + public Rgb e870; + public Rgb e871; + public Rgb e872; + public Rgb e873; + public Rgb e874; + public Rgb e875; + public Rgb e876; + public Rgb e877; + public Rgb e878; + public Rgb e879; + public Rgb e880; + public Rgb e881; + public Rgb e882; + public Rgb e883; + public Rgb e884; + public Rgb e885; + public Rgb e886; + public Rgb e887; + public Rgb e888; + public Rgb e889; + public Rgb e890; + public Rgb e891; + public Rgb e892; + public Rgb e893; + public Rgb e894; + public Rgb e895; + public Rgb e896; + public Rgb e897; + public Rgb e898; + public Rgb e899; + public Rgb e900; + public Rgb e901; + public Rgb e902; + public Rgb e903; + public Rgb e904; + public Rgb e905; + public Rgb e906; + public Rgb e907; + public Rgb e908; + public Rgb e909; + public Rgb e910; + public Rgb e911; + public Rgb e912; + public Rgb e913; + public Rgb e914; + public Rgb e915; + public Rgb e916; + public Rgb e917; + public Rgb e918; + public Rgb e919; + public Rgb e920; + public Rgb e921; + public Rgb e922; + public Rgb e923; + public Rgb e924; + public Rgb e925; + public Rgb e926; + public Rgb e927; + public Rgb e928; + public Rgb e929; + public Rgb e930; + public Rgb e931; + public Rgb e932; + public Rgb e933; + public Rgb e934; + public Rgb e935; + public Rgb e936; + public Rgb e937; + public Rgb e938; + public Rgb e939; + public Rgb e940; + public Rgb e941; + public Rgb e942; + public Rgb e943; + public Rgb e944; + public Rgb e945; + public Rgb e946; + public Rgb e947; + public Rgb e948; + public Rgb e949; + public Rgb e950; + public Rgb e951; + public Rgb e952; + public Rgb e953; + public Rgb e954; + public Rgb e955; + public Rgb e956; + public Rgb e957; + public Rgb e958; + public Rgb e959; + public Rgb e960; + public Rgb e961; + public Rgb e962; + public Rgb e963; + public Rgb e964; + public Rgb e965; + public Rgb e966; + public Rgb e967; + public Rgb e968; + public Rgb e969; + public Rgb e970; + public Rgb e971; + public Rgb e972; + public Rgb e973; + public Rgb e974; + public Rgb e975; + public Rgb e976; + public Rgb e977; + public Rgb e978; + public Rgb e979; + public Rgb e980; + public Rgb e981; + public Rgb e982; + public Rgb e983; + public Rgb e984; + public Rgb e985; + public Rgb e986; + public Rgb e987; + public Rgb e988; + public Rgb e989; + public Rgb e990; + public Rgb e991; + public Rgb e992; + public Rgb e993; + public Rgb e994; + public Rgb e995; + public Rgb e996; + public Rgb e997; + public Rgb e998; + public Rgb e999; + public Rgb e1000; + public Rgb e1001; + public Rgb e1002; + public Rgb e1003; + public Rgb e1004; + public Rgb e1005; + public Rgb e1006; + public Rgb e1007; + public Rgb e1008; + public Rgb e1009; + public Rgb e1010; + public Rgb e1011; + public Rgb e1012; + public Rgb e1013; + public Rgb e1014; + public Rgb e1015; + public Rgb e1016; + public Rgb e1017; + public Rgb e1018; + public Rgb e1019; + public Rgb e1020; + public Rgb e1021; + public Rgb e1022; + public Rgb e1023; + public Rgb e1024; + + [UnscopedRef] + public ref Rgb this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref AsSpan()[index]; + } + } + + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() + { + return MemoryMarshal.CreateSpan(ref e0, 1025); + } + } +} + +/// +/// DXGI_GAMMA_CONTROL_CAPABILITIES +public partial struct GammaControlCapabilities +{ + /// + public Bool32 ScaleAndOffsetSupported; + + /// + public float MaxConvertedValue; + + /// + public float MinConvertedValue; + + /// + public uint NumGammaControlPoints; + + /// + public unsafe fixed float ControlPointPositions[1025]; +} + +/// +/// DXGI_MODE_DESC +public partial struct ModeDescription +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public Rational RefreshRate; + + /// + public Format Format; + + /// + public ModeScanlineOrder ScanlineOrdering; + + /// + public ModeScaling Scaling; +} + +/// +/// DXGI_JPEG_DC_HUFFMAN_TABLE +public partial struct JpegDCHuffmanTable +{ + /// + public unsafe fixed byte CodeCounts[12]; + + /// + public unsafe fixed byte CodeValues[12]; +} + +/// +/// DXGI_JPEG_AC_HUFFMAN_TABLE +public partial struct JpegAcHuffmanTable +{ + /// + public unsafe fixed byte CodeCounts[16]; + + /// + public unsafe fixed byte CodeValues[162]; +} + +/// +/// DXGI_JPEG_QUANTIZATION_TABLE +public partial struct JpegQuantizationTable +{ + /// + public unsafe fixed byte Elements[64]; +} diff --git a/NuGet.config b/NuGet.config index 804d468..fbcef10 100644 --- a/NuGet.config +++ b/NuGet.config @@ -1,10 +1,5 @@ - - - - - diff --git a/global.json b/global.json index 60af8e2..eac464b 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "9.0.100", + "version": "9.0.301", "rollForward": "latestFeature", "allowPrerelease": false } diff --git a/samples/01-ClearScreen/Program.cs b/samples/01-ClearScreen/Program.cs index 852862c..fc2a609 100644 --- a/samples/01-ClearScreen/Program.cs +++ b/samples/01-ClearScreen/Program.cs @@ -60,7 +60,7 @@ public static unsafe class Program private static void TestDxc() { using ComPtr compiler = default; - DxcCreateInstance(CLSID_DxcCompiler, __uuidof(), compiler.GetVoidAddressOf()); + DxcCreateInstance(CLSID_DxcCompiler, __uuidof(), (void**)compiler.GetAddressOf()); } private static void TestWic() @@ -98,11 +98,11 @@ public static unsafe class Program ThrowIfFailed(D2D1CreateFactory(FactoryType.MultiThreaded, __uuidof(), default, - d2d1Factory2.GetVoidAddressOf())); + (void**)d2d1Factory2.GetAddressOf())); using ComPtr dwriteFactory = default; ThrowIfFailed( - DWriteCreateFactory(DWriteFactoryType.Shared, __uuidof(), dwriteFactory.GetVoidAddressOf())); + DWriteCreateFactory(DWriteFactoryType.Shared, __uuidof(), (void**)dwriteFactory.GetAddressOf())); using ComPtr textFormat = dwriteFactory.Get()->CreateTextFormat( @@ -216,7 +216,7 @@ public static unsafe class Program (IUnknown*)adapter.Get(), FeatureLevel.Level_11_0, __uuidof(), - device.GetVoidAddressOf() + (void**)device.GetAddressOf() ); ThrowIfFailed(hr); diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index 17c4a7c..9ebffdc 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -1228,7 +1228,7 @@ public static class Program { string repoDir = Path.Combine(currentDir, "Vortice.Win32"); Console.WriteLine("looking for Vortice.Win32 at '{0}'", repoDir); - if (Directory.Exists(repoDir)) + if (Directory.Exists(repoDir) && !repoDir.Contains("artifacts")) { return repoDir; } @@ -1248,7 +1248,7 @@ public static class Program public static int Main() { string repoRoot = FindRepoRoot(); - string rootPath = new DirectoryInfo(repoRoot).Parent!.FullName; + string rootPath = Path.Combine(new DirectoryInfo(repoRoot)!.FullName, "src"); string dxgiPath = Path.Combine(rootPath, "Vortice.Win32.Graphics.Dxgi"); string d3d9Path = Path.Combine(rootPath, "Vortice.Win32.Graphics.Direct3D9"); string d3d11Path = Path.Combine(rootPath, "Vortice.Win32.Graphics.Direct3D11"); @@ -3328,7 +3328,7 @@ public static class Program var j = "0x" + guid.Substring(28, 2).ToUpperInvariant(); var k = "0x" + guid.Substring(30, 2).ToUpperInvariant(); - writer.WriteLine("ReadOnlySpan data = new byte[] {"); + writer.WriteLine("ReadOnlySpan data = ["); writer.WriteLine($"{'\t'}{_1}, {_2}, {_3}, {_4},"); writer.WriteLine($"{'\t'}{_5}, {_6},"); writer.WriteLine($"{'\t'}{_7}, {_8},"); @@ -3340,7 +3340,7 @@ public static class Program writer.WriteLine($"{'\t'}{i},"); writer.WriteLine($"{'\t'}{j},"); writer.WriteLine($"{'\t'}{k}"); - writer.WriteLine("};"); + writer.WriteLine("];"); writer.WriteLine(); writer.WriteLine("Debug.Assert(data.Length == Unsafe.SizeOf());"); diff --git a/src/Generator/win32json/api/Graphics.CompositionSwapchain.json b/src/Generator/win32json/api/Graphics.CompositionSwapchain.json index 254b279..35b6d11 100644 --- a/src/Generator/win32json/api/Graphics.CompositionSwapchain.json +++ b/src/Generator/win32json/api/Graphics.CompositionSwapchain.json @@ -216,6 +216,28 @@ } ] } + ,{ + "Name":"IPresentationSurface2" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"95609569-c5f0-47f9-8804-5345f2e2767e" + ,"Interface":{"Kind":"ApiRef","Name":"IPresentationSurface","TargetKind":"Com","Api":"Graphics.CompositionSwapchain","Parents":[]} + ,"Methods":[ + { + "Name":"SetIsHdrContent" + ,"SetLastError":false + ,"ReturnType":{"Kind":"Native","Name":"Void"} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"isHdrContent","Type":{"Kind":"Native","Name":"Byte"},"Attrs":["In"]} + ] + } + ] + } ,{ "Name":"IPresentStatistics" ,"Architectures":[] @@ -461,6 +483,16 @@ } ] } + ,{ + "Name":"IPresentationFactory_SupportHdrAware" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"2bd0b885-a16f-4bd9-a59a-d073e069d416" + ,"Interface":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]} + ,"Methods":[ + ] + } ,{ "Name":"PresentStatus" ,"Architectures":[] diff --git a/src/Generator/win32json/api/Graphics.DXCore.json b/src/Generator/win32json/api/Graphics.DXCore.json index 72d4e20..f87fa2e 100644 --- a/src/Generator/win32json/api/Graphics.DXCore.json +++ b/src/Generator/win32json/api/Graphics.DXCore.json @@ -29,6 +29,48 @@ ,"Value":"248e2800-a793-4724-abaa-23a6de1be090" ,"Attrs":[] } + ,{ + "Name":"DXCORE_ADAPTER_ATTRIBUTE_D3D12_GENERIC_ML" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"b71b0d41-1088-422f-a27c-0250b7d3a988" + ,"Attrs":[] + } + ,{ + "Name":"DXCORE_ADAPTER_ATTRIBUTE_D3D12_GENERIC_MEDIA" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"8eb2c848-82f6-4b49-aa87-aecfcf0174c6" + ,"Attrs":[] + } + ,{ + "Name":"DXCORE_HARDWARE_TYPE_ATTRIBUTE_GPU" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"b69eb219-3ded-4464-979f-a00bd4687006" + ,"Attrs":[] + } + ,{ + "Name":"DXCORE_HARDWARE_TYPE_ATTRIBUTE_COMPUTE_ACCELERATOR" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"e0b195da-58ef-4a22-90f1-1f28169cab8d" + ,"Attrs":[] + } + ,{ + "Name":"DXCORE_HARDWARE_TYPE_ATTRIBUTE_NPU" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"d46140c4-add7-451b-9e56-06fe8c3b58ed" + ,"Attrs":[] + } + ,{ + "Name":"DXCORE_HARDWARE_TYPE_ATTRIBUTE_MEDIA_ACCELERATOR" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"66bdb96a-050b-44c7-a4fd-d144ce0ab443" + ,"Attrs":[] + } ] ,"Types":[ @@ -55,6 +97,9 @@ ,{"Name":"IsIntegrated","Value":12} ,{"Name":"IsDetachable","Value":13} ,{"Name":"HardwareIDParts","Value":14} + ,{"Name":"PhysicalAdapterCount","Value":15} + ,{"Name":"AdapterEngineCount","Value":16} + ,{"Name":"AdapterEngineName","Value":17} ] ,"IntegerBase":"UInt32" } @@ -68,6 +113,15 @@ ,"Values":[ {"Name":"IsDriverUpdateInProgress","Value":0} ,{"Name":"AdapterMemoryBudget","Value":1} + ,{"Name":"AdapterMemoryUsageBytes","Value":2} + ,{"Name":"AdapterMemoryUsageByProcessBytes","Value":3} + ,{"Name":"AdapterEngineRunningTimeMicroseconds","Value":4} + ,{"Name":"AdapterEngineRunningTimeByProcessMicroseconds","Value":5} + ,{"Name":"AdapterTemperatureCelsius","Value":6} + ,{"Name":"AdapterInUseProcessCount","Value":7} + ,{"Name":"AdapterInUseProcessSet","Value":8} + ,{"Name":"AdapterEngineFrequencyHertz","Value":9} + ,{"Name":"AdapterMemoryFrequencyHertz","Value":10} ] ,"IntegerBase":"UInt32" } @@ -113,6 +167,51 @@ ] ,"IntegerBase":"UInt32" } + ,{ + "Name":"DXCoreWorkload" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"Graphics","Value":0} + ,{"Name":"Compute","Value":1} + ,{"Name":"Media","Value":2} + ,{"Name":"MachineLearning","Value":3} + ] + ,"IntegerBase":"UInt32" + } + ,{ + "Name":"DXCoreRuntimeFilterFlags" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":true + ,"Scoped":false + ,"Values":[ + {"Name":"None","Value":0} + ,{"Name":"D3D11","Value":1} + ,{"Name":"D3D12","Value":2} + ] + ,"IntegerBase":"UInt32" + } + ,{ + "Name":"DXCoreHardwareTypeFilterFlags" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":true + ,"Scoped":false + ,"Values":[ + {"Name":"None","Value":0} + ,{"Name":"GPU","Value":1} + ,{"Name":"ComputeAccelerator","Value":2} + ,{"Name":"NPU","Value":4} + ,{"Name":"MediaAccelerator","Value":8} + ] + ,"IntegerBase":"UInt32" + } ,{ "Name":"DXCoreHardwareID" ,"Architectures":[] @@ -180,6 +279,201 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"DXCoreAdapterEngineIndex" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"physicalAdapterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"engineIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreEngineQueryInput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"adapterEngineIndex","Type":{"Kind":"ApiRef","Name":"DXCoreAdapterEngineIndex","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":[]} + ,{"Name":"processId","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreEngineQueryOutput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"runningTime","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"processQuerySucceeded","Type":{"Kind":"Native","Name":"Byte"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreMemoryType" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"Dedicated","Value":0} + ,{"Name":"Shared","Value":1} + ] + ,"IntegerBase":"UInt32" + } + ,{ + "Name":"DXCoreMemoryUsage" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"committed","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"resident","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreMemoryQueryInput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"physicalAdapterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"memoryType","Type":{"Kind":"ApiRef","Name":"DXCoreMemoryType","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreProcessMemoryQueryInput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"physicalAdapterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"memoryType","Type":{"Kind":"ApiRef","Name":"DXCoreMemoryType","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":[]} + ,{"Name":"processId","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreProcessMemoryQueryOutput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"memoryUsage","Type":{"Kind":"ApiRef","Name":"DXCoreMemoryUsage","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":[]} + ,{"Name":"processQuerySucceeded","Type":{"Kind":"Native","Name":"Byte"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreAdapterProcessSetQueryInput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"arraySize","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"processIds","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreAdapterProcessSetQueryOutput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"processesWritten","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"processesTotal","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreEngineNamePropertyInput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"adapterEngineIndex","Type":{"Kind":"ApiRef","Name":"DXCoreAdapterEngineIndex","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":[]} + ,{"Name":"engineNameLength","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"engineName","Type":{"Kind":"ApiRef","Name":"PWSTR","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreEngineNamePropertyOutput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"engineNameLength","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"DXCoreFrequencyQueryOutput" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"frequency","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"maxFrequency","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"maxOverclockedFrequency","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"PFN_DXCORE_NOTIFICATION_CALLBACK" ,"Architectures":[] @@ -336,6 +630,32 @@ } ] } + ,{ + "Name":"IDXCoreAdapter1" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"a0783366-cfa3-43be-9d79-55b2da97c63c" + ,"Interface":{"Kind":"ApiRef","Name":"IDXCoreAdapter","TargetKind":"Com","Api":"Graphics.DXCore","Parents":[]} + ,"Methods":[ + { + "Name":"GetPropertyWithInput" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"property","Type":{"Kind":"ApiRef","Name":"DXCoreAdapterProperty","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":["In"]} + ,{"Name":"inputPropertyDetailsSize","Type":{"Kind":"Native","Name":"UIntPtr"},"Attrs":["In"]} + ,{"Name":"inputPropertyDetails","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}},"Attrs":["In",{"Kind":"MemorySize","BytesParamIndex":1},"Optional","Const"]} + ,{"Name":"outputBufferSize","Type":{"Kind":"Native","Name":"UIntPtr"},"Attrs":["In"]} + ,{"Name":"outputBuffer","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}},"Attrs":["Out",{"Kind":"MemorySize","BytesParamIndex":3}]} + ] + } + ] + } ,{ "Name":"IDXCoreAdapterList" ,"Architectures":[] @@ -499,6 +819,32 @@ } ] } + ,{ + "Name":"IDXCoreAdapterFactory1" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"d5682e19-6d21-401c-827a-9a51a4ea35d7" + ,"Interface":{"Kind":"ApiRef","Name":"IDXCoreAdapterFactory","TargetKind":"Com","Api":"Graphics.DXCore","Parents":[]} + ,"Methods":[ + { + "Name":"CreateAdapterListByWorkload" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"workload","Type":{"Kind":"ApiRef","Name":"DXCoreWorkload","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":["In"]} + ,{"Name":"runtimeFilter","Type":{"Kind":"ApiRef","Name":"DXCoreRuntimeFilterFlags","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":["In"]} + ,{"Name":"hardwareTypeFilter","Type":{"Kind":"ApiRef","Name":"DXCoreHardwareTypeFilterFlags","TargetKind":"Default","Api":"Graphics.DXCore","Parents":[]},"Attrs":["In"]} + ,{"Name":"riid","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Guid"}},"Attrs":["In","Const"]} + ,{"Name":"ppvAdapterList","Type":{"Kind":"PointerTo","Child":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}}},"Attrs":["Out","ComOutPtr"]} + ] + } + ] + } ] ,"Functions":[ diff --git a/src/Generator/win32json/api/Graphics.Direct2D.Common.json b/src/Generator/win32json/api/Graphics.Direct2D.Common.json index 811f2de..07b47ec 100644 --- a/src/Generator/win32json/api/Graphics.Direct2D.Common.json +++ b/src/Generator/win32json/api/Graphics.Direct2D.Common.json @@ -237,25 +237,6 @@ ] ,"NestedTypes":[ { - "Name":"_Anonymous2_e__Struct" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Struct" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"_11","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"_12","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"_21","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"_22","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"_31","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"_32","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } - ,{ "Name":"_Anonymous1_e__Struct" ,"Architectures":[] ,"Platform":null @@ -274,6 +255,25 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_Anonymous2_e__Struct" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"_11","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"_12","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"_21","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"_22","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"_31","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"_32","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ] diff --git a/src/Generator/win32json/api/Graphics.Direct3D.Dxc.json b/src/Generator/win32json/api/Graphics.Direct3D.Dxc.json index 71abb52..33cb473 100644 --- a/src/Generator/win32json/api/Graphics.Direct3D.Dxc.json +++ b/src/Generator/win32json/api/Graphics.Direct3D.Dxc.json @@ -309,6 +309,8 @@ {"Name":"DXC_CP_ACP","Value":0} ,{"Name":"DXC_CP_UTF16","Value":1200} ,{"Name":"DXC_CP_UTF8","Value":65001} + ,{"Name":"DXC_CP_UTF32","Value":12000} + ,{"Name":"DXC_CP_WIDE","Value":1200} ] ,"IntegerBase":"UInt32" } @@ -736,7 +738,7 @@ ] } ,{ - "Name":"GetBlobAsUtf16" + "Name":"GetBlobAsWide" ,"SetLastError":false ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} ,"ReturnAttrs":[] @@ -968,7 +970,7 @@ {"Name":"pData","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}},"Attrs":["In",{"Kind":"MemorySize","BytesParamIndex":1},"Const"]} ,{"Name":"size","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} ,{"Name":"codePage","Type":{"Kind":"ApiRef","Name":"DXC_CP","TargetKind":"Default","Api":"Graphics.Direct3D.Dxc","Parents":[]},"Attrs":["In"]} - ,{"Name":"pBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} ] } ,{ @@ -984,7 +986,7 @@ ,{"Name":"pIMalloc","Type":{"Kind":"ApiRef","Name":"IMalloc","TargetKind":"Com","Api":"System.Com","Parents":[]},"Attrs":["In"]} ,{"Name":"size","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} ,{"Name":"codePage","Type":{"Kind":"ApiRef","Name":"DXC_CP","TargetKind":"Default","Api":"Graphics.Direct3D.Dxc","Parents":[]},"Attrs":["In"]} - ,{"Name":"pBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} ] } ,{ @@ -999,7 +1001,7 @@ {"Name":"pData","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}},"Attrs":["In",{"Kind":"MemorySize","BytesParamIndex":1},"Const"]} ,{"Name":"size","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} ,{"Name":"codePage","Type":{"Kind":"ApiRef","Name":"DXC_CP","TargetKind":"Default","Api":"Graphics.Direct3D.Dxc","Parents":[]},"Attrs":["In"]} - ,{"Name":"pBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} ] } ,{ @@ -1013,7 +1015,7 @@ ,"Params":[ {"Name":"pFileName","Type":{"Kind":"ApiRef","Name":"PWSTR","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":["In","Const"]} ,{"Name":"pCodePage","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"DXC_CP","TargetKind":"Default","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["In","Optional"]} - ,{"Name":"pBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} ] } ,{ @@ -1051,11 +1053,11 @@ ,"Attrs":[] ,"Params":[ {"Name":"pBlob","Type":{"Kind":"ApiRef","Name":"IDxcBlob","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]},"Attrs":["In"]} - ,{"Name":"pBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf8","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf8","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} ] } ,{ - "Name":"GetBlobAsUtf16" + "Name":"GetBlobAsWide" ,"SetLastError":false ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} ,"ReturnAttrs":[] @@ -1064,7 +1066,7 @@ ,"Attrs":[] ,"Params":[ {"Name":"pBlob","Type":{"Kind":"ApiRef","Name":"IDxcBlob","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]},"Attrs":["In"]} - ,{"Name":"pBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppBlobEncoding","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} ] } ,{ @@ -1150,6 +1152,11 @@ ,{"Name":"DXC_OUT_REFLECTION","Value":8} ,{"Name":"DXC_OUT_ROOT_SIGNATURE","Value":9} ,{"Name":"DXC_OUT_EXTRA_OUTPUTS","Value":10} + ,{"Name":"DXC_OUT_REMARKS","Value":11} + ,{"Name":"DXC_OUT_TIME_REPORT","Value":12} + ,{"Name":"DXC_OUT_TIME_TRACE","Value":13} + ,{"Name":"DXC_OUT_LAST","Value":13} + ,{"Name":"DXC_OUT_NUM_ENUMS","Value":14} ] ,"IntegerBase":"Int32" } @@ -2043,6 +2050,323 @@ } ] } + ,{ + "Name":"IDxcPdbUtils2" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"4315d938-f369-4f93-95a2-252017cc3807" + ,"Interface":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]} + ,"Methods":[ + { + "Name":"Load" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pPdbOrDxil","Type":{"Kind":"ApiRef","Name":"IDxcBlob","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]},"Attrs":["In"]} + ] + } + ,{ + "Name":"GetSourceCount" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"GetSource" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobEncoding","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetSourceName" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetLibraryPDBCount" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["In","Out"]} + ] + } + ,{ + "Name":"GetLibraryPDB" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppOutPdbUtils","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcPdbUtils2","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppLibraryName","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr","Optional"]} + ] + } + ,{ + "Name":"GetFlagCount" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"GetFlag" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetArgCount" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"GetArg" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetArgPairCount" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"GetArgPair" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppName","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ,{"Name":"ppValue","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetDefineCount" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"GetDefine" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"uIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetTargetProfile" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetEntryPoint" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetMainFileName" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetHash" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlob","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetName" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlobUtf16","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetVersionInfo" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppVersionInfo","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcVersionInfo","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetCustomToolchainID" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pID","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"GetCustomToolchainData" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppBlob","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlob","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetWholeDxil" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppResult","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"IDxcBlob","TargetKind":"Com","Api":"Graphics.Direct3D.Dxc","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"IsFullPDB" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"BOOL","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + ] + } + ,{ + "Name":"IsPDBRef" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"BOOL","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + ] + } + ] + } ] ,"Functions":[ diff --git a/src/Generator/win32json/api/Graphics.Direct3D11.json b/src/Generator/win32json/api/Graphics.Direct3D11.json index 79c2c69..35fac8c 100644 --- a/src/Generator/win32json/api/Graphics.Direct3D11.json +++ b/src/Generator/win32json/api/Graphics.Direct3D11.json @@ -2892,6 +2892,76 @@ ,"Value":"107af0e0-ef1a-4d19-aba8-67a163073d13" ,"Attrs":[] } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MONOCHROME" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"0685b993-3d8c-43a0-8b28-d74c2d6899a4" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MONOCHROME10" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"142a1d0f-69dd-4ec9-8591-b12ffcb91a29" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN12" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"1a72925f-0c2c-4f15-96fb-b17d1473603f" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10_422" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"0bac4fe5-1532-4429-a854-f84de04953db" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN12_422" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"55bcac81-f311-4093-a7d0-1cbc0b849bee" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN_444" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"4008018f-f537-4b36-98cf-61af8a2c1a33" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10_EXT" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"9cc55490-e37c-4932-8684-4920f9f6409c" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10_444" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"0dabeffa-4458-4602-bc03-0795659d617c" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN12_444" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"9798634d-fe9d-48e5-b4da-dbec45b3df01" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_HEVC_VLD_MAIN16" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"a4fbdbb0-a113-482b-a232-635cc0697f6d" + ,"Attrs":[] + } ,{ "Name":"D3D11_DECODER_PROFILE_VP9_VLD_PROFILE0" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -2948,6 +3018,55 @@ ,"Value":"2d80bed6-9cac-4835-9e91-327bbc4f9ee8" ,"Attrs":[] } + ,{ + "Name":"D3D11_DECODER_PROFILE_MJPEG_VLD_420" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"725cb506-0c29-43c4-9440-8e9397903a04" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_MJPEG_VLD_422" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"5b77b9cd-1a35-4c30-9fd8-ef4b60c035dd" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_MJPEG_VLD_444" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"d95161f9-0d44-47e6-bcf5-1bfbfb268f97" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_MJPEG_VLD_4444" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"c91748d5-fd18-4aca-9db3-3a6634ab547d" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_JPEG_VLD_420" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"cf782c83-bef5-4a2c-87cb-6019e7b175ac" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_JPEG_VLD_422" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"f04df417-eee2-4067-a778-f35c15ab9721" + ,"Attrs":[] + } + ,{ + "Name":"D3D11_DECODER_PROFILE_JPEG_VLD_444" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"4cd00e17-89ba-48ef-b9f9-edcb82713f65" + ,"Attrs":[] + } ,{ "Name":"D3D11_CRYPTO_TYPE_AES128_CTR" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -3813,6 +3932,7 @@ ,{"Name":"D3D11_RESOURCE_MISC_HW_PROTECTED","Value":524288} ,{"Name":"D3D11_RESOURCE_MISC_SHARED_DISPLAYABLE","Value":1048576} ,{"Name":"D3D11_RESOURCE_MISC_SHARED_EXCLUSIVE_WRITER","Value":2097152} + ,{"Name":"D3D11_RESOURCE_MISC_NO_SHADER_ACCESS","Value":4194304} ] ,"IntegerBase":"Int32" } @@ -6045,6 +6165,7 @@ ,{"Name":"D3D11_FEATURE_SHADER_CACHE","Value":18} ,{"Name":"D3D11_FEATURE_D3D11_OPTIONS5","Value":19} ,{"Name":"D3D11_FEATURE_DISPLAYABLE","Value":20} + ,{"Name":"D3D11_FEATURE_D3D11_OPTIONS6","Value":21} ] ,"IntegerBase":"Int32" } @@ -6432,6 +6553,33 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER_0","Value":0} + ,{"Name":"D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER_1","Value":1} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D11_FEATURE_DATA_D3D11_OPTIONS6" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"ShaderAccessRestrictedResourceTier","Type":{"Kind":"ApiRef","Name":"D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER","TargetKind":"Default","Api":"Graphics.Direct3D11","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"ID3D11DeviceContext" ,"Architectures":[] @@ -7991,6 +8139,7 @@ ,{"Name":"D3D11_VIDEO_DECODER_BUFFER_BITSTREAM","Value":6} ,{"Name":"D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR","Value":7} ,{"Name":"D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN","Value":8} + ,{"Name":"D3D11_VIDEO_DECODER_BUFFER_HUFFMAN_TABLE","Value":9} ] ,"IntegerBase":"Int32" } @@ -13028,7 +13177,8 @@ ,{"Name":"D3D11_MESSAGE_ID_NO_TRACKED_WORKLOAD_SLOT_AVAILABLE","Value":3146281} ,{"Name":"D3D11_MESSAGE_ID_END_TRACKED_WORKLOAD_INVALID_ARG","Value":3146282} ,{"Name":"D3D11_MESSAGE_ID_TRACKED_WORKLOAD_DISJOINT_FAILURE","Value":3146283} - ,{"Name":"D3D11_MESSAGE_ID_D3D11_5_MESSAGES_END","Value":3146284} + ,{"Name":"D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_AND_WRITE_MASK_MISMATCH","Value":3146284} + ,{"Name":"D3D11_MESSAGE_ID_D3D11_5_MESSAGES_END","Value":3146285} ] ,"IntegerBase":"Int32" } @@ -18272,7 +18422,7 @@ ,"Params":[ {"Name":"pAdapter","Type":{"Kind":"ApiRef","Name":"IDXGIAdapter","TargetKind":"Com","Api":"Graphics.Dxgi","Parents":[]},"Attrs":["In","Optional"]} ,{"Name":"DriverType","Type":{"Kind":"ApiRef","Name":"D3D_DRIVER_TYPE","TargetKind":"Default","Api":"Graphics.Direct3D","Parents":[]},"Attrs":["In"]} - ,{"Name":"Software","Type":{"Kind":"ApiRef","Name":"HMODULE","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":["In"]} + ,{"Name":"Software","Type":{"Kind":"ApiRef","Name":"HMODULE","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":["Optional"]} ,{"Name":"Flags","Type":{"Kind":"ApiRef","Name":"D3D11_CREATE_DEVICE_FLAG","TargetKind":"Default","Api":"Graphics.Direct3D11","Parents":[]},"Attrs":["In"]} ,{"Name":"pFeatureLevels","Type":{"Kind":"LPArray","NullNullTerm":false,"CountConst":-1,"CountParamIndex":5,"Child":{"Kind":"ApiRef","Name":"D3D_FEATURE_LEVEL","TargetKind":"Default","Api":"Graphics.Direct3D","Parents":[]}},"Attrs":["In","Optional","Const"]} ,{"Name":"FeatureLevels","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} diff --git a/src/Generator/win32json/api/Graphics.Direct3D12.json b/src/Generator/win32json/api/Graphics.Direct3D12.json index f7c1fa5..5fdcfb1 100644 --- a/src/Generator/win32json/api/Graphics.Direct3D12.json +++ b/src/Generator/win32json/api/Graphics.Direct3D12.json @@ -1930,7 +1930,7 @@ "Name":"D3D12_PREVIEW_SDK_VERSION" ,"Type":{"Kind":"Native","Name":"UInt32"} ,"ValueType":"UInt32" - ,"Value":714 + ,"Value":717 ,"Attrs":[] } ,{ @@ -2406,7 +2406,7 @@ "Name":"D3D12_SDK_VERSION" ,"Type":{"Kind":"Native","Name":"UInt32"} ,"ValueType":"UInt32" - ,"Value":614 + ,"Value":616 ,"Attrs":[] } ,{ @@ -2773,6 +2773,20 @@ ,"Value":512 ,"Attrs":[] } + ,{ + "Name":"D3D12_TIGHT_ALIGNMENT_MIN_COMMITTED_RESOURCE_ALIGNEMNT" + ,"Type":{"Kind":"Native","Name":"UInt32"} + ,"ValueType":"UInt32" + ,"Value":4096 + ,"Attrs":[] + } + ,{ + "Name":"D3D12_TIGHT_ALIGNMENT_MIN_PLACED_RESOURCE_ALIGNEMNT" + ,"Type":{"Kind":"Native","Name":"UInt32"} + ,"ValueType":"UInt32" + ,"Value":8 + ,"Attrs":[] + } ,{ "Name":"D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES" ,"Type":{"Kind":"Native","Name":"UInt32"} @@ -3011,6 +3025,13 @@ ,"Value":32 ,"Attrs":[] } + ,{ + "Name":"LUID_DEFINED" + ,"Type":{"Kind":"Native","Name":"UInt32"} + ,"ValueType":"UInt32" + ,"Value":1 + ,"Attrs":[] + } ,{ "Name":"D3D12_SHADER_COMPONENT_MAPPING_MASK" ,"Type":{"Kind":"Native","Name":"UInt32"} @@ -3074,13 +3095,6 @@ ,"Value":64 ,"Attrs":[] } - ,{ - "Name":"LUID_DEFINED" - ,"Type":{"Kind":"Native","Name":"UInt32"} - ,"ValueType":"UInt32" - ,"Value":1 - ,"Attrs":[] - } ,{ "Name":"D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -3123,6 +3137,13 @@ ,"Value":"114863bf-c386-4aee-b39d-8f0bbb062955" ,"Attrs":[] } + ,{ + "Name":"CLSID_D3D12DSRDeviceFactory" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"bb6dd27e-94a9-41a6-9f1b-133772172428" + ,"Attrs":[] + } ,{ "Name":"D3D12_SHADING_RATE_X_AXIS_SHIFT" ,"Type":{"Kind":"Native","Name":"UInt32"} @@ -3333,6 +3354,13 @@ ,"Value":"c9c4725f-a81a-4f56-8c5b-c51039d694fb" ,"Attrs":[] } + ,{ + "Name":"D3D12GPUUploadHeapsOnUnsupportedOS" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"45dc51f3-767f-4588-b206-0baa2b16fbae" + ,"Attrs":[] + } ] ,"Types":[ @@ -4285,6 +4313,8 @@ ,{"Name":"D3D12_FEATURE_PLACED_RESOURCE_SUPPORT_INFO","Value":51} ,{"Name":"D3D12_FEATURE_HARDWARE_COPY","Value":52} ,{"Name":"D3D12_FEATURE_D3D12_OPTIONS21","Value":53} + ,{"Name":"D3D12_FEATURE_APPLICATION_SPECIFIC_DRIVER_STATE","Value":56} + ,{"Name":"D3D12_FEATURE_BYTECODE_BYPASS_HASH_SUPPORTED","Value":57} ] ,"IntegerBase":"Int32" } @@ -4952,6 +4982,7 @@ {"Name":"D3D12_RAYTRACING_TIER_NOT_SUPPORTED","Value":0} ,{"Name":"D3D12_RAYTRACING_TIER_1_0","Value":10} ,{"Name":"D3D12_RAYTRACING_TIER_1_1","Value":11} + ,{"Name":"D3D12_RAYTRACING_TIER_1_2","Value":12} ] ,"IntegerBase":"Int32" } @@ -5372,6 +5403,34 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"D3D12_FEATURE_DATA_APPLICATION_SPECIFIC_DRIVER_STATE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"Supported","Type":{"Kind":"ApiRef","Name":"BOOL","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"D3D12_FEATURE_DATA_BYTECODE_BYPASS_HASH_SUPPORTED" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"Supported","Type":{"Kind":"ApiRef","Name":"BOOL","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"D3D12_RESOURCE_ALLOCATION_INFO" ,"Architectures":[] @@ -7800,6 +7859,23 @@ ,{"Name":"ppRootSignatureDeserializer","Type":{"Kind":"PointerTo","Child":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}}},"Attrs":["Out"]} ] } + ,{ + "Name":"PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER_FROM_SUBOBJECT_IN_LIBRARY" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"FunctionPointer" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Attrs":[] + ,"Params":[ + {"Name":"pSrcData","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}},"Attrs":["In",{"Kind":"MemorySize","BytesParamIndex":1},"Const"]} + ,{"Name":"SrcDataSizeInBytes","Type":{"Kind":"Native","Name":"UIntPtr"},"Attrs":["In"]} + ,{"Name":"RootSignatureSubobjectName","Type":{"Kind":"ApiRef","Name":"PWSTR","TargetKind":"Default","Api":"Foundation","Parents":[]},"Attrs":["In","Const"]} + ,{"Name":"pRootSignatureDeserializerInterface","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Guid"}},"Attrs":["In","Const"]} + ,{"Name":"ppRootSignatureDeserializer","Type":{"Kind":"PointerTo","Child":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}}},"Attrs":["Out"]} + ] + } ,{ "Name":"D3D12_CPU_DESCRIPTOR_HANDLE" ,"Architectures":[] @@ -8132,51 +8208,6 @@ ] ,"NestedTypes":[ { - "Name":"_IncrementingConstant_e__Struct" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Struct" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"RootParameterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ,{"Name":"DestOffsetIn32BitValues","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } - ,{ - "Name":"_ShaderResourceView_e__Struct" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Struct" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"RootParameterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } - ,{ - "Name":"_Constant_e__Struct" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Struct" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"RootParameterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ,{"Name":"DestOffsetIn32BitValues","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ,{"Name":"Num32BitValuesToSet","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } - ,{ "Name":"_UnorderedAccessView_e__Struct" ,"Architectures":[] ,"Platform":null @@ -8190,6 +8221,20 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_ConstantBufferView_e__Struct" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"RootParameterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"_VertexBuffer_e__Struct" ,"Architectures":[] @@ -8205,7 +8250,7 @@ ] } ,{ - "Name":"_ConstantBufferView_e__Struct" + "Name":"_ShaderResourceView_e__Struct" ,"Architectures":[] ,"Platform":null ,"Kind":"Struct" @@ -8218,6 +8263,37 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_IncrementingConstant_e__Struct" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"RootParameterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"DestOffsetIn32BitValues","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"_Constant_e__Struct" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"RootParameterIndex","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"DestOffsetIn32BitValues","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"Num32BitValuesToSet","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ] @@ -11569,6 +11645,7 @@ {"Name":"D3D12_RAYTRACING_PIPELINE_FLAG_NONE","Value":0} ,{"Name":"D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES","Value":256} ,{"Name":"D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES","Value":512} + ,{"Name":"D3D12_RAYTRACING_PIPELINE_FLAG_ALLOW_OPACITY_MICROMAPS","Value":1024} ] ,"IntegerBase":"Int32" } @@ -11877,6 +11954,7 @@ ,"Values":[ {"Name":"D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES","Value":0} ,{"Name":"D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS","Value":1} + ,{"Name":"D3D12_RAYTRACING_GEOMETRY_TYPE_OMM_TRIANGLES","Value":2} ] ,"IntegerBase":"Int32" } @@ -11893,6 +11971,8 @@ ,{"Name":"D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE","Value":2} ,{"Name":"D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE","Value":4} ,{"Name":"D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE","Value":8} + ,{"Name":"D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OMM_2_STATE","Value":16} + ,{"Name":"D3D12_RAYTRACING_INSTANCE_FLAG_DISABLE_OMMS","Value":32} ] ,"IntegerBase":"Int32" } @@ -11996,6 +12076,96 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT","Value":-1} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE","Value":-2} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT","Value":-3} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE","Value":-4} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_STATE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_TRANSPARENT","Value":0} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_OPAQUE","Value":1} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT","Value":2} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE","Value":3} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_2_STATE","Value":1} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_4_STATE","Value":2} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"ByteOffset","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"_bitfield","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[{"Kind":"NativeBitfield","Name":"SubdivisionLevel","Offset":"0","Length":"16"},{"Kind":"NativeBitfield","Name":"Format","Offset":"16","Length":"16"}]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"OpacityMicromapIndexBuffer","Type":{"Kind":"ApiRef","Name":"D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ,{"Name":"OpacityMicromapIndexFormat","Type":{"Kind":"ApiRef","Name":"DXGI_FORMAT","TargetKind":"Default","Api":"Graphics.Dxgi.Common","Parents":[]},"Attrs":[]} + ,{"Name":"OpacityMicromapBaseLocation","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"OpacityMicromapArray","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"pTriangles","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["Const"]} + ,{"Name":"pOmmLinkage","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["Const"]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS" ,"Architectures":[] @@ -12011,6 +12181,8 @@ ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD","Value":8} ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY","Value":16} ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE","Value":32} + ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_UPDATE","Value":64} + ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_DISABLE_OMMS","Value":128} ] ,"IntegerBase":"Int32" } @@ -12040,6 +12212,7 @@ ,"Values":[ {"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL","Value":0} ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL","Value":1} + ,{"Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_ARRAY","Value":2} ] ,"IntegerBase":"Int32" } @@ -12139,9 +12312,24 @@ ,"SizeField":"" ,"Fields":[ {"Name":"SerializedSizeInBytes","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} - ,{"Name":"NumBottomLevelAccelerationStructurePointers","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"Anonymous","Type":{"Kind":"ApiRef","Name":"_Anonymous_e__Union","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} ] ,"NestedTypes":[ + { + "Name":"_Anonymous_e__Union" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Union" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"NumBottomLevelAccelerationStructurePointers","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"NumBottomLevelAccelerationStructureHeaderAndPointerListPairs","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ,{ @@ -12168,6 +12356,7 @@ ,"Scoped":false ,"Values":[ {"Name":"D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE","Value":0} + ,{"Name":"D3D12_SERIALIZED_DATA_APPLICATION_SPECIFIC_DRIVER_STATE","Value":1} ] ,"IntegerBase":"Int32" } @@ -12204,6 +12393,80 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_NONE","Value":0} + ,{"Name":"D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BOTTOM_LEVEL_POINTERS","Value":0} + ,{"Name":"D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BLOCKS","Value":-1} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER1" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"DriverMatchingIdentifier","Type":{"Kind":"ApiRef","Name":"D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ,{"Name":"SerializedSizeInBytesIncludingHeader","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"DeserializedSizeInBytes","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"Anonymous","Type":{"Kind":"ApiRef","Name":"_Anonymous_e__Union","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ,{"Name":"HeaderPostambleType","Type":{"Kind":"ApiRef","Name":"D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + { + "Name":"_Anonymous_e__Union" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Union" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"NumBottomLevelAccelerationStructurePointersAfterHeader","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"NumBlocks","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ] + } + ,{ + "Name":"D3D12_SERIALIZED_BLOCK_TYPE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAPS","Value":0} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D12_RAYTRACING_SERIALIZED_BLOCK" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"Type","Type":{"Kind":"ApiRef","Name":"D3D12_SERIALIZED_BLOCK_TYPE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ,{"Name":"NumBlockPointersAfterHeader","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC" ,"Architectures":[] @@ -12260,12 +12523,46 @@ ,"Fields":[ {"Name":"Triangles","Type":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} ,{"Name":"AABBs","Type":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_AABBS_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ,{"Name":"OmmTriangles","Type":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} ] ,"NestedTypes":[ ] } ] } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"Count","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"SubdivisionLevel","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"Format","Type":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"NumOmmHistogramEntries","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"pOmmHistogram","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["Const"]} + ,{"Name":"InputBuffer","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"PerOmmDescs","Type":{"Kind":"ApiRef","Name":"D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS" ,"Architectures":[] @@ -12294,6 +12591,7 @@ {"Name":"InstanceDescs","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} ,{"Name":"pGeometryDescs","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["Const"]} ,{"Name":"ppGeometryDescs","Type":{"Kind":"PointerTo","Child":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_GEOMETRY_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}}},"Attrs":["Const"]} + ,{"Name":"pOpacityMicromapArrayDesc","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["Const"]} ] ,"NestedTypes":[ ] @@ -12333,6 +12631,62 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE","Value":0} + ,{"Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION","Value":1} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"DestBuffer","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ,{"Name":"InfoType","Type":{"Kind":"ApiRef","Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"CurrentSizeInBytes","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"DecodedSizeInBytes","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"D3D12_RAY_FLAGS" ,"Architectures":[] @@ -12352,6 +12706,7 @@ ,{"Name":"D3D12_RAY_FLAG_CULL_NON_OPAQUE","Value":128} ,{"Name":"D3D12_RAY_FLAG_SKIP_TRIANGLES","Value":256} ,{"Name":"D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES","Value":512} + ,{"Name":"D3D12_RAY_FLAG_FORCE_OMM_2_STATE","Value":1024} ] ,"IntegerBase":"Int32" } @@ -12546,6 +12901,7 @@ ,{"Name":"D3D12_AUTO_BREADCRUMB_OP_BEGIN_COMMAND_LIST","Value":46} ,{"Name":"D3D12_AUTO_BREADCRUMB_OP_DISPATCHGRAPH","Value":47} ,{"Name":"D3D12_AUTO_BREADCRUMB_OP_SETPROGRAM","Value":48} + ,{"Name":"D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES2","Value":52} ] ,"IntegerBase":"Int32" } @@ -14768,6 +15124,155 @@ } ] } + ,{ + "Name":"ID3D12Tools1" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"e4fbc019-dd3c-43e1-8f32-7f649575f0a0" + ,"Interface":{"Kind":"ApiRef","Name":"ID3D12Tools","TargetKind":"Com","Api":"Graphics.Direct3D12","Parents":[]} + ,"Methods":[ + { + "Name":"ReserveGPUVARangesAtCreate" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pRanges","Type":{"Kind":"LPArray","NullNullTerm":false,"CountConst":-1,"CountParamIndex":1,"Child":{"Kind":"ApiRef","Name":"D3D12_GPU_VIRTUAL_ADDRESS_RANGE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["In"]} + ,{"Name":"uiNumRanges","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ] + } + ,{ + "Name":"ClearReservedGPUVARangesList" + ,"SetLastError":false + ,"ReturnType":{"Kind":"Native","Name":"Void"} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + ] + } + ] + } + ,{ + "Name":"ID3D12Tools2" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"01d393c5-c9b0-42a1-958c-c26b02d4d097" + ,"Interface":{"Kind":"ApiRef","Name":"ID3D12Tools1","TargetKind":"Com","Api":"Graphics.Direct3D12","Parents":[]} + ,"Methods":[ + { + "Name":"SetApplicationSpecificDriverState" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pAdapter","Type":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]},"Attrs":["In"]} + ,{"Name":"pBlob","Type":{"Kind":"ApiRef","Name":"ID3DBlob","TargetKind":"Com","Api":"Graphics.Direct3D","Parents":[]},"Attrs":["In","Optional"]} + ] + } + ] + } + ,{ + "Name":"ID3D12PageableTools" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"8f1359db-d8d1-42f9-b5cf-79f4cbad0d3d" + ,"Interface":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]} + ,"Methods":[ + { + "Name":"GetAllocation" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pAllocation","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"D3D12_GPU_VIRTUAL_ADDRESS_RANGE","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]}},"Attrs":["In","Out","RetVal"]} + ] + } + ] + } + ,{ + "Name":"ID3D12DeviceTools" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"2ea68e9c-19c3-4e47-a109-6cdadff0aca9" + ,"Interface":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]} + ,"Methods":[ + { + "Name":"SetNextAllocationAddress" + ,"SetLastError":false + ,"ReturnType":{"Kind":"Native","Name":"Void"} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"nextAllocationVirtualAddress","Type":{"Kind":"Native","Name":"UInt64"},"Attrs":["In"]} + ] + } + ] + } + ,{ + "Name":"D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_UNKNOWN","Value":1} + ,{"Name":"D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_USED","Value":2} + ,{"Name":"D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_IGNORED","Value":3} + ,{"Name":"D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_NOT_SPECIFIED","Value":4} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"ID3D12DeviceTools1" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"e30e9fc7-e641-4d6e-8a81-9dd9206ec47a" + ,"Interface":{"Kind":"ApiRef","Name":"ID3D12DeviceTools","TargetKind":"Com","Api":"Graphics.Direct3D12","Parents":[]} + ,"Methods":[ + { + "Name":"GetApplicationSpecificDriverState" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"ppBlob","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"ID3DBlob","TargetKind":"Com","Api":"Graphics.Direct3D","Parents":[]}},"Attrs":["Out","ComOutPtr"]} + ] + } + ,{ + "Name":"GetApplicationSpecificDriverBlobStatus" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS","TargetKind":"Default","Api":"Graphics.Direct3D12","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + ] + } + ] + } ,{ "Name":"D3D12_SUBRESOURCE_DATA" ,"Architectures":[] @@ -15038,6 +15543,7 @@ {"Name":"D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS","Value":0} ,{"Name":"D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS","Value":1} ,{"Name":"D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR","Value":2} + ,{"Name":"D3D12_DEBUG_DEVICE_PARAMETER_BYTECODE_VALIDATION_MODE","Value":3} ] ,"IntegerBase":"Int32" } @@ -15119,6 +15625,21 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED","Value":0} + ,{"Name":"D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED","Value":1} + ,{"Name":"D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE","Value":2} + ,{"Name":"D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE_DEFAULT","Value":1} + ] + ,"IntegerBase":"Int32" + } ,{ "Name":"ID3D12DebugDevice1" ,"Architectures":[] @@ -16630,7 +17151,12 @@ ,{"Name":"D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INSTANCE_COUNT_ZERO","Value":1418} ,{"Name":"D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SET_BEFORE_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG","Value":1419} ,{"Name":"D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG","Value":1420} - ,{"Name":"D3D12_MESSAGE_ID_D3D12_MESSAGES_END","Value":1421} + ,{"Name":"D3D12_MESSAGE_ID_APPLICATION_SPECIFIC_DRIVER_STATE_NOT_SUPPORTED","Value":1421} + ,{"Name":"D3D12_MESSAGE_ID_RENDER_TARGET_OR_DEPTH_STENCIL_RESOUCE_NOT_INITIALIZED","Value":1422} + ,{"Name":"D3D12_MESSAGE_ID_BYTECODE_VALIDATION_ERROR","Value":1423} + ,{"Name":"D3D12_MESSAGE_ID_FENCE_ZERO_WAIT","Value":1424} + ,{"Name":"D3D12_MESSAGE_ID_NON_COMMON_RESOURCE_IN_COPY_QUEUE","Value":1425} + ,{"Name":"D3D12_MESSAGE_ID_D3D12_MESSAGES_END","Value":1426} ] ,"IntegerBase":"Int32" } @@ -17762,6 +18288,31 @@ } ] } + ,{ + "Name":"ID3D12DSRDeviceFactory" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"f343d1a0-afe3-439f-b13d-cd87a43b70ca" + ,"Interface":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]} + ,"Methods":[ + { + "Name":"CreateDSRDevice" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pD3D12Device","Type":{"Kind":"ApiRef","Name":"ID3D12Device","TargetKind":"Com","Api":"Graphics.Direct3D12","Parents":[]},"Attrs":["In"]} + ,{"Name":"NodeMask","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"riid","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Guid"}},"Attrs":["In","Const"]} + ,{"Name":"ppvDSRDevice","Type":{"Kind":"PointerTo","Child":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Void"}}},"Attrs":["Out","ComOutPtr"]} + ] + } + ] + } ,{ "Name":"ID3D12GBVDiagnostics" ,"Architectures":[] diff --git a/src/Generator/win32json/api/Graphics.Direct3D9.json b/src/Generator/win32json/api/Graphics.Direct3D9.json index 02dc987..28e92ad 100644 --- a/src/Generator/win32json/api/Graphics.Direct3D9.json +++ b/src/Generator/win32json/api/Graphics.Direct3D9.json @@ -2682,6 +2682,13 @@ ,"Value":16 ,"Attrs":[] } + ,{ + "Name":"D3DSHADER_INSTRUCTION_PREDICATED" + ,"Type":{"Kind":"Native","Name":"UInt32"} + ,"ValueType":"UInt32" + ,"Value":268435456 + ,"Attrs":[] + } ,{ "Name":"D3DSP_DCL_USAGE_SHIFT" ,"Type":{"Kind":"Native","Name":"UInt32"} @@ -10856,21 +10863,6 @@ ,"NestedTypes":[ ] } - ,{ - "Name":"_Anonymous4_e__Union" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Union" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"rhw","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"dvRHW","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } ,{ "Name":"_Anonymous8_e__Union" ,"Architectures":[] @@ -10886,6 +10878,21 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_Anonymous4_e__Union" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Union" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"rhw","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"dvRHW","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ,{ @@ -11123,21 +11130,6 @@ ,"NestedTypes":[ ] } - ,{ - "Name":"_Anonymous5_e__Union" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Union" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"ny","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"dvNY","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } ,{ "Name":"_Anonymous1_e__Union" ,"Architectures":[] @@ -11153,6 +11145,21 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_Anonymous5_e__Union" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Union" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"ny","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"dvNY","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ,{ @@ -11324,21 +11331,6 @@ ,"NestedTypes":[ ] } - ,{ - "Name":"_Anonymous5_e__Union" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Union" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"power","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"dvPower","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } ,{ "Name":"_Anonymous1_e__Union" ,"Architectures":[] @@ -11354,6 +11346,21 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_Anonymous5_e__Union" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Union" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"power","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"dvPower","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ,{ diff --git a/src/Generator/win32json/api/Graphics.DirectDraw.json b/src/Generator/win32json/api/Graphics.DirectDraw.json index 697e77a..44c61cb 100644 --- a/src/Generator/win32json/api/Graphics.DirectDraw.json +++ b/src/Generator/win32json/api/Graphics.DirectDraw.json @@ -11746,21 +11746,6 @@ ,"NestedTypes":[ ] } - ,{ - "Name":"_Anonymous1_e__Union" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Union" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"lPitch","Type":{"Kind":"Native","Name":"Int32"},"Attrs":[]} - ,{"Name":"dwLinearSize","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } ,{ "Name":"_Anonymous5_e__Union" ,"Architectures":[] @@ -11776,6 +11761,21 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"_Anonymous1_e__Union" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Union" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"lPitch","Type":{"Kind":"Native","Name":"Int32"},"Attrs":[]} + ,{"Name":"dwLinearSize","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ] } ,{ diff --git a/src/Generator/win32json/api/Graphics.DirectWrite.json b/src/Generator/win32json/api/Graphics.DirectWrite.json index b39460d..3a6edfe 100644 --- a/src/Generator/win32json/api/Graphics.DirectWrite.json +++ b/src/Generator/win32json/api/Graphics.DirectWrite.json @@ -9418,6 +9418,39 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"PAINT_SWEEP_GRADIENT" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"extendMode","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"gradientStopCount","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ,{"Name":"centerX","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"centerY","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"startAngle","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ,{"Name":"endAngle","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } + ,{ + "Name":"PAINT_LAYERS" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Struct" + ,"Size":0 + ,"PackingSize":0 + ,"SizeField":"" + ,"Fields":[ + {"Name":"childCount","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} + ] + ,"NestedTypes":[ + ] + } ,{ "Name":"PAINT_COLOR_GLYPH" ,"Architectures":[] @@ -9454,39 +9487,6 @@ ,"NestedTypes":[ ] } - ,{ - "Name":"PAINT_LAYERS" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Struct" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"childCount","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } - ,{ - "Name":"PAINT_SWEEP_GRADIENT" - ,"Architectures":[] - ,"Platform":null - ,"Kind":"Struct" - ,"Size":0 - ,"PackingSize":0 - ,"SizeField":"" - ,"Fields":[ - {"Name":"extendMode","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ,{"Name":"gradientStopCount","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":[]} - ,{"Name":"centerX","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"centerY","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"startAngle","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ,{"Name":"endAngle","Type":{"Kind":"Native","Name":"Single"},"Attrs":[]} - ] - ,"NestedTypes":[ - ] - } ] } ] diff --git a/src/Generator/win32json/api/Graphics.Dwm.json b/src/Generator/win32json/api/Graphics.Dwm.json index 477b837..3a19d11 100644 --- a/src/Generator/win32json/api/Graphics.Dwm.json +++ b/src/Generator/win32json/api/Graphics.Dwm.json @@ -193,7 +193,8 @@ ,{"Name":"DWMWA_TEXT_COLOR","Value":36} ,{"Name":"DWMWA_VISIBLE_FRAME_BORDER_THICKNESS","Value":37} ,{"Name":"DWMWA_SYSTEMBACKDROP_TYPE","Value":38} - ,{"Name":"DWMWA_LAST","Value":39} + ,{"Name":"DWMWA_REDIRECTIONBITMAP_ALPHA","Value":39} + ,{"Name":"DWMWA_LAST","Value":40} ] ,"IntegerBase":"Int32" } diff --git a/src/Generator/win32json/api/Graphics.Dxgi.json b/src/Generator/win32json/api/Graphics.Dxgi.json index 6645c87..abaa527 100644 --- a/src/Generator/win32json/api/Graphics.Dxgi.json +++ b/src/Generator/win32json/api/Graphics.Dxgi.json @@ -288,6 +288,13 @@ ,"Value":-2005270428 ,"Attrs":[] } + ,{ + "Name":"DXGI_ERROR_SETDISPLAYMODE_REQUIRED" + ,"Type":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ValueType":"Int32" + ,"Value":-2005270427 + ,"Attrs":[] + } ] ,"Types":[ diff --git a/src/Generator/win32json/api/Graphics.Gdi.json b/src/Generator/win32json/api/Graphics.Gdi.json index e2af146..ad0c11c 100644 --- a/src/Generator/win32json/api/Graphics.Gdi.json +++ b/src/Generator/win32json/api/Graphics.Gdi.json @@ -3690,6 +3690,13 @@ ,"Value":8 ,"Attrs":[] } + ,{ + "Name":"DISPLAYCONFIG_PATH_BOOST_REFRESH_RATE" + ,"Type":{"Kind":"Native","Name":"UInt32"} + ,"ValueType":"UInt32" + ,"Value":16 + ,"Attrs":[] + } ,{ "Name":"DISPLAYCONFIG_PATH_VALID_FLAGS" ,"Type":{"Kind":"Native","Name":"UInt32"} @@ -8703,6 +8710,20 @@ ] ,"IntegerBase":"Int32" } + ,{ + "Name":"DISPLAYCONFIG_ADVANCED_COLOR_MODE" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"DISPLAYCONFIG_ADVANCED_COLOR_MODE_SDR","Value":0} + ,{"Name":"DISPLAYCONFIG_ADVANCED_COLOR_MODE_WCG","Value":1} + ,{"Name":"DISPLAYCONFIG_ADVANCED_COLOR_MODE_HDR","Value":2} + ] + ,"IntegerBase":"Int32" + } ,{ "Name":"RGNDATAHEADER" ,"Architectures":[] @@ -15958,10 +15979,10 @@ ,"Platform":"windows5.0" ,"Attrs":[] ,"Params":[ - {"Name":"param0","Type":{"Kind":"ApiRef","Name":"HDC","TargetKind":"Default","Api":"Graphics.Gdi","Parents":[]},"Attrs":["In"]} - ,{"Name":"param1","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"RECT","TargetKind":"Default","Api":"Foundation","Parents":[]}},"Attrs":["In","Out"]} - ,{"Name":"param2","Type":{"Kind":"ApiRef","Name":"DFC_TYPE","TargetKind":"Default","Api":"Graphics.Gdi","Parents":[]},"Attrs":["In"]} - ,{"Name":"param3","Type":{"Kind":"ApiRef","Name":"DFCS_STATE","TargetKind":"Default","Api":"Graphics.Gdi","Parents":[]},"Attrs":["In"]} + {"Name":"hdc","Type":{"Kind":"ApiRef","Name":"HDC","TargetKind":"Default","Api":"Graphics.Gdi","Parents":[]},"Attrs":["In"]} + ,{"Name":"lprc","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"RECT","TargetKind":"Default","Api":"Foundation","Parents":[]}},"Attrs":["In","Out"]} + ,{"Name":"uType","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"uState","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} ] } ,{ diff --git a/src/Generator/win32json/api/Graphics.GdiPlus.json b/src/Generator/win32json/api/Graphics.GdiPlus.json index a3c8d78..ff04717 100644 --- a/src/Generator/win32json/api/Graphics.GdiPlus.json +++ b/src/Generator/win32json/api/Graphics.GdiPlus.json @@ -3919,6 +3919,19 @@ ,"NestedTypes":[ ] } + ,{ + "Name":"Version" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"V2","Value":2} + ,{"Name":"V3","Value":3} + ] + ,"IntegerBase":"UInt32" + } ,{ "Name":"GdiplusStartupParams" ,"Architectures":[] @@ -3930,6 +3943,7 @@ {"Name":"GdiplusStartupDefault","Value":0} ,{"Name":"GdiplusStartupNoSetRound","Value":1} ,{"Name":"GdiplusStartupSetPSValue","Value":2} + ,{"Name":"GdiplusStartupReserved0","Value":4} ,{"Name":"GdiplusStartupTransparencyMask","Value":-16777216} ] ,"IntegerBase":"Int32" diff --git a/src/Generator/win32json/api/Graphics.Imaging.json b/src/Generator/win32json/api/Graphics.Imaging.json index 9459543..81395d0 100644 --- a/src/Generator/win32json/api/Graphics.Imaging.json +++ b/src/Generator/win32json/api/Graphics.Imaging.json @@ -218,6 +218,20 @@ ,"Value":"41945702-8302-44a6-9445-ac98e8afa086" ,"Attrs":[] } + ,{ + "Name":"CLSID_WICJpegXLDecoder" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"fc6ceece-aef5-4a23-96ec-5984ffb486d9" + ,"Attrs":[] + } + ,{ + "Name":"CLSID_WICJpegXLEncoder" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"0e4ecd3b-1ba6-4636-8198-56c73040964a" + ,"Attrs":[] + } ,{ "Name":"GUID_ContainerFormatBmp" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -302,6 +316,13 @@ ,"Value":"fe99ce60-f19c-433c-a3ae-00acefa9ca21" ,"Attrs":[] } + ,{ + "Name":"GUID_ContainerFormatJpegXL" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"fec14e3f-427a-4736-aae6-27ed84f69322" + ,"Attrs":[] + } ,{ "Name":"CLSID_WICImagingCategories" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -533,6 +554,20 @@ ,"Value":"e6cd0116-eeba-4161-aa85-27dd9fb3a895" ,"Attrs":[] } + ,{ + "Name":"GUID_WICPixelFormat8bppDepth" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"4c9c9f45-1d89-4e31-9bc7-69343a0dca69" + ,"Attrs":[] + } + ,{ + "Name":"GUID_WICPixelFormat8bppGain" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"a884022a-af13-4c16-b746-619bf618b878" + ,"Attrs":[] + } ,{ "Name":"GUID_WICPixelFormat16bppBGR555" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -1541,6 +1576,20 @@ ,"Value":"43c105ee-b93b-4abb-b003-a08c0d870471" ,"Attrs":[] } + ,{ + "Name":"GUID_MetadataFormatJpegXLAnim" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"501c2e24-7a7d-42b2-93c7-b4f45bcc92f7" + ,"Attrs":[] + } + ,{ + "Name":"GUID_MetadataFormatJpegXLAnimFrame" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"958ecc2c-36cb-4af9-9ea8-0b74baccfd3e" + ,"Attrs":[] + } ,{ "Name":"CLSID_WICUnknownMetadataReader" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -2094,6 +2143,13 @@ ,"Value":"2438de3d-94d9-4be8-84a8-4de95a575e75" ,"Attrs":[] } + ,{ + "Name":"CLSID_WICHeifHDRMetadataWriter" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"b83135a2-8e7e-485e-a533-f93621dd93c8" + ,"Attrs":[] + } ,{ "Name":"CLSID_WICWebpAnimMetadataReader" ,"Type":{"Kind":"Native","Name":"Guid"} @@ -2108,6 +2164,34 @@ ,"Value":"85a10b03-c9f6-439f-be5e-c0fbef67807c" ,"Attrs":[] } + ,{ + "Name":"CLSID_WICJpegXLAnimMetadataReader" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"bf8b6eb0-37e2-4ed8-8289-be9ae31d9f03" + ,"Attrs":[] + } + ,{ + "Name":"CLSID_WICJpegXLAnimMetadataWriter" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"39d01345-432b-44e6-afd6-f606d20a5571" + ,"Attrs":[] + } + ,{ + "Name":"CLSID_WICJpegXLAnimFrameMetadataReader" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"9cdf50a8-8770-4fe6-aef2-d06e2c01744f" + ,"Attrs":[] + } + ,{ + "Name":"CLSID_WICJpegXLAnimFrameMetadataWriter" + ,"Type":{"Kind":"Native","Name":"Guid"} + ,"ValueType":"String" + ,"Value":"d1ce58a8-06e0-4b6f-8fc1-577560bd5ad9" + ,"Attrs":[] + } ] ,"Types":[ @@ -2726,6 +2810,33 @@ ] ,"IntegerBase":"Int32" } + ,{ + "Name":"WICJpegXLAnimProperties" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"WICJpegXLAnimLoopCount","Value":1} + ,{"Name":"WICJpegXLAnimFrameTicksPerSecondNumerator","Value":2} + ,{"Name":"WICJpegXLAnimFrameTicksPerSecondDenominator","Value":3} + ] + ,"IntegerBase":"Int32" + } + ,{ + "Name":"WICJpegXLAnimFrameProperties" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"WICJpegXLAnimFrameDurationInTicks","Value":1} + ,{"Name":"WICJpegXLAnimFrameName","Value":2} + ] + ,"IntegerBase":"Int32" + } ,{ "Name":"WICSectionAccessLevel" ,"Architectures":[] @@ -4273,6 +4384,31 @@ } ] } + ,{ + "Name":"IWICBitmapSourceTransform2" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"c3373fdf-6d39-4e5f-8e79-bf40c0b7ed77" + ,"Interface":{"Kind":"ApiRef","Name":"IWICBitmapSourceTransform","TargetKind":"Com","Api":"Graphics.Imaging","Parents":[]} + ,"Methods":[ + { + "Name":"GetColorContextsForPixelFormat" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pPixelFormat","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Guid"}},"Attrs":["In"]} + ,{"Name":"cCount","Type":{"Kind":"Native","Name":"UInt32"},"Attrs":["In"]} + ,{"Name":"ppIColorContexts","Type":{"Kind":"LPArray","NullNullTerm":false,"CountConst":-1,"CountParamIndex":1,"Child":{"Kind":"ApiRef","Name":"IWICColorContext","TargetKind":"Com","Api":"Graphics.Imaging","Parents":[]}},"Attrs":["In"]} + ,{"Name":"pcActualCount","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"UInt32"}},"Attrs":["Out"]} + ] + } + ] + } ,{ "Name":"IWICPlanarBitmapSourceTransform" ,"Architectures":[] @@ -4414,6 +4550,53 @@ } ] } + ,{ + "Name":"IWICDisplayAdaptationControl" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Com" + ,"Guid":"de9d91d2-70b4-4f41-836c-25fcd39626d3" + ,"Interface":{"Kind":"ApiRef","Name":"IUnknown","TargetKind":"Com","Api":"System.Com","Parents":[]} + ,"Methods":[ + { + "Name":"DoesSupportChangingMaxLuminance" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pguidDstFormat","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Guid"}},"Attrs":["In"]} + ,{"Name":"pfIsSupported","Type":{"Kind":"PointerTo","Child":{"Kind":"ApiRef","Name":"BOOL","TargetKind":"Default","Api":"Foundation","Parents":[]}},"Attrs":["Out"]} + ] + } + ,{ + "Name":"SetDisplayMaxLuminance" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"fLuminanceInNits","Type":{"Kind":"Native","Name":"Single"},"Attrs":["In"]} + ] + } + ,{ + "Name":"GetDisplayMaxLuminance" + ,"SetLastError":false + ,"ReturnType":{"Kind":"ApiRef","Name":"HRESULT","TargetKind":"Default","Api":"Foundation","Parents":[]} + ,"ReturnAttrs":[] + ,"Architectures":[] + ,"Platform":null + ,"Attrs":[] + ,"Params":[ + {"Name":"pfLuminanceInNits","Type":{"Kind":"PointerTo","Child":{"Kind":"Native","Name":"Single"}},"Attrs":["Out","RetVal"]} + ] + } + ] + } ,{ "Name":"IWICProgressCallback" ,"Architectures":[] @@ -5381,6 +5564,21 @@ ] ,"IntegerBase":"Int32" } + ,{ + "Name":"WICHeifCompressionOption" + ,"Architectures":[] + ,"Platform":null + ,"Kind":"Enum" + ,"Flags":false + ,"Scoped":false + ,"Values":[ + {"Name":"WICHeifCompressionDontCare","Value":0} + ,{"Name":"WICHeifCompressionNone","Value":1} + ,{"Name":"WICHeifCompressionHEVC","Value":2} + ,{"Name":"WICHeifCompressionAV1","Value":3} + ] + ,"IntegerBase":"Int32" + } ,{ "Name":"WICNamedWhitePoint" ,"Architectures":[] diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/Graphics.Direct2D.Apis.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/Graphics.Direct2D.Apis.cs index 05dcc30..e22e4a8 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/Graphics.Direct2D.Apis.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/Graphics.Direct2D.Apis.cs @@ -18,7 +18,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0x74, 0xA9, 0x6A, 0x54, 0x63, 0xFC, 0x4C, @@ -30,7 +30,7 @@ public static partial class Apis 0x62, 0xC9, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -42,7 +42,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0B, 0x4D, 0x84, 0xC2, 0x86, 0x3D, 0xE7, 0x46, @@ -54,7 +54,7 @@ public static partial class Apis 0x40, 0xF3, 0xFB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -66,7 +66,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x04, 0x7B, 0x46, 0xE8, 0x61, 0xEC, 0x8A, 0x4B, @@ -78,7 +78,7 @@ public static partial class Apis 0xEB, 0xEA, 0x5A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -90,7 +90,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0x14, 0x15, 0xFC, 0x9A, 0x04, 0x84, 0x47, @@ -102,7 +102,7 @@ public static partial class Apis 0xF2, 0x09, 0x87 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -114,7 +114,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE4, 0x2B, 0x3E, 0x91, 0xCF, 0xFD, 0xE2, 0x4F, @@ -126,7 +126,7 @@ public static partial class Apis 0x4F, 0xF4, 0x08 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -138,7 +138,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4D, 0xC2, 0xB6, 0x5F, 0xDD, 0xC6, 0x31, 0x42, @@ -150,7 +150,7 @@ public static partial class Apis 0xC3, 0x25, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -162,7 +162,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7B, 0xB7, 0xC5, 0x81, 0xF8, 0x13, 0xDD, 0x4C, @@ -174,7 +174,7 @@ public static partial class Apis 0x7A, 0xC6, 0x5D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -186,7 +186,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC0, 0x49, 0x2D, 0x2A, 0xCF, 0x4A, 0xC7, 0x43, @@ -198,7 +198,7 @@ public static partial class Apis 0x87, 0x4D, 0x27 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -210,7 +210,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1E, 0x8D, 0xEA, 0x8C, 0xB0, 0x77, 0x86, 0x49, @@ -222,7 +222,7 @@ public static partial class Apis 0xAE, 0x78, 0x87 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -234,7 +234,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4C, 0x52, 0x28, 0x1A, 0xD6, 0xFD, 0xA4, 0x4A, @@ -246,7 +246,7 @@ public static partial class Apis 0x26, 0x7B, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -258,7 +258,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0x03, 0x1F, 0x92, 0x1C, 0x64, 0xDF, 0x47, @@ -270,7 +270,7 @@ public static partial class Apis 0x53, 0xAE, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -282,7 +282,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0x9F, 0xFC, 0x48, 0xAC, 0xF6, 0xF1, 0x48, @@ -294,7 +294,7 @@ public static partial class Apis 0x46, 0xF7, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -306,7 +306,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x08, 0x8C, 0x7F, 0x40, 0x33, 0x55, 0x31, 0x43, @@ -318,7 +318,7 @@ public static partial class Apis 0x77, 0x84, 0x3E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -330,7 +330,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x10, 0x71, 0x3F, 0xE2, 0x9A, 0x0E, 0x24, 0x43, @@ -342,7 +342,7 @@ public static partial class Apis 0x46, 0xF3, 0x5B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -354,7 +354,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0x19, 0x43, 0x17, 0xE9, 0x58, 0xB2, 0x49, @@ -366,7 +366,7 @@ public static partial class Apis 0x11, 0xA3, 0xDB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -378,7 +378,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCD, 0x6F, 0x86, 0x90, 0x8E, 0x48, 0x4B, 0x45, @@ -390,7 +390,7 @@ public static partial class Apis 0x66, 0xC3, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -402,7 +402,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x64, 0x83, 0xC4, 0xED, 0x17, 0x04, 0x11, 0x41, @@ -414,7 +414,7 @@ public static partial class Apis 0xA9, 0xF8, 0x90 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -426,7 +426,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0xFD, 0x7E, 0x3E, 0x2D, 0xA3, 0xD4, 0x46, @@ -438,7 +438,7 @@ public static partial class Apis 0x9A, 0xC9, 0x54 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -450,7 +450,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE5, 0x1E, 0x8C, 0x42, 0xB8, 0x77, 0x50, 0x44, @@ -462,7 +462,7 @@ public static partial class Apis 0x21, 0xAB, 0xDA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -474,7 +474,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC7, 0xC5, 0x26, 0x6C, 0xE0, 0x34, 0xFC, 0x46, @@ -486,7 +486,7 @@ public static partial class Apis 0x06, 0xE2, 0x28 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -498,7 +498,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x20, 0x3C, 0xC2, 0x61, 0x69, 0xAE, 0x8E, 0x4D, @@ -510,7 +510,7 @@ public static partial class Apis 0xF6, 0x38, 0xF2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -522,7 +522,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0x44, 0x94, 0x40, 0x19, 0xC4, 0xA0, 0x41, @@ -534,7 +534,7 @@ public static partial class Apis 0xA1, 0x8E, 0x42 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -546,7 +546,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x69, 0x6D, 0xEB, 0x1F, 0xE6, 0x2F, 0xC9, 0x4A, @@ -558,7 +558,7 @@ public static partial class Apis 0xE7, 0xA6, 0xA5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -570,7 +570,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x69, 0x93, 0xAF, 0x9D, 0x46, 0x38, 0x0E, 0x4D, @@ -582,7 +582,7 @@ public static partial class Apis 0x34, 0xA5, 0xD7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -594,7 +594,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD0, 0xB7, 0x1D, 0x88, 0xEE, 0xF7, 0x4D, 0x4D, @@ -606,7 +606,7 @@ public static partial class Apis 0xC6, 0x6E, 0xE8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -618,7 +618,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEC, 0x58, 0x44, 0x0F, 0x32, 0x4B, 0x1B, 0x49, @@ -630,7 +630,7 @@ public static partial class Apis 0x4D, 0x3E, 0xB6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -642,7 +642,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFD, 0xC8, 0x47, 0xAD, 0xEF, 0x63, 0xCC, 0x4A, @@ -654,7 +654,7 @@ public static partial class Apis 0x03, 0x6C, 0x06 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -666,7 +666,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB7, 0x1A, 0x25, 0x41, 0xEB, 0x0B, 0xF8, 0x46, @@ -678,7 +678,7 @@ public static partial class Apis 0xCC, 0xE5, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -690,7 +690,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0D, 0xC4, 0xE6, 0xEA, 0x6A, 0x62, 0x2D, 0x4C, @@ -702,7 +702,7 @@ public static partial class Apis 0xAB, 0xE2, 0x02 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -714,7 +714,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6A, 0x00, 0x53, 0x6C, 0x50, 0x44, 0x99, 0x41, @@ -726,7 +726,7 @@ public static partial class Apis 0xFE, 0xCE, 0x5E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -738,7 +738,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x03, 0xE3, 0xB9, 0x8C, 0xC0, 0x91, 0x4F, @@ -750,7 +750,7 @@ public static partial class Apis 0xC4, 0x8C, 0x20 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -762,7 +762,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x26, 0xCA, 0xC3, 0x09, 0xE2, 0x3A, 0x09, 0x4F, @@ -774,7 +774,7 @@ public static partial class Apis 0xD5, 0x3F, 0x22 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -786,7 +786,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0xB4, 0xEA, 0x06, 0xED, 0xDE, 0x18, 0x40, @@ -798,7 +798,7 @@ public static partial class Apis 0x1A, 0xDE, 0xB2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -810,7 +810,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCF, 0xD9, 0xB2, 0x5C, 0x7D, 0x32, 0x9F, 0x45, @@ -822,7 +822,7 @@ public static partial class Apis 0x08, 0x6B, 0xF7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -834,7 +834,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x61, 0xA3, 0x7E, 0xC6, 0x63, 0x18, 0x69, 0x4E, @@ -846,7 +846,7 @@ public static partial class Apis 0x9A, 0x5B, 0x6B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -858,7 +858,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x05, 0x11, 0x8A, 0x81, 0x32, 0x79, 0xF4, 0x44, @@ -870,7 +870,7 @@ public static partial class Apis 0x2F, 0x2C, 0x93 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -882,7 +882,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1E, 0x42, 0xAE, 0xED, 0x54, 0x76, 0x37, 0x4A, @@ -894,7 +894,7 @@ public static partial class Apis 0xBE, 0xB3, 0xC1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -906,7 +906,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x18, 0xF8, 0x5B, 0x43, 0x5E, 0xCB, 0x48, @@ -918,7 +918,7 @@ public static partial class Apis 0xD6, 0xA1, 0xD4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -930,7 +930,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x38, 0x41, 0x78, 0xB0, 0x76, 0x3B, 0xC5, 0x4B, @@ -942,7 +942,7 @@ public static partial class Apis 0x02, 0x65, 0x9F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -954,7 +954,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAE, 0xB6, 0x2B, 0xCF, 0x9A, 0x88, 0xD7, 0x4A, @@ -966,7 +966,7 @@ public static partial class Apis 0x2C, 0x9F, 0xC9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -978,7 +978,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x89, 0xC4, 0x9A, 0xFB, 0x8D, 0xAD, 0xED, 0x41, @@ -990,7 +990,7 @@ public static partial class Apis 0xD1, 0x10, 0xF7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1002,7 +1002,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC1, 0x3C, 0x50, 0x99, 0xC7, 0x66, 0xC9, 0x45, @@ -1014,7 +1014,7 @@ public static partial class Apis 0x91, 0x44, 0x01 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1026,7 +1026,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0xA7, 0x48, 0xB6, 0xD5, 0x0E, 0x80, 0x4F, @@ -1038,7 +1038,7 @@ public static partial class Apis 0xCA, 0x6B, 0x77 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1050,7 +1050,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEC, 0xE5, 0xF3, 0x23, 0xE8, 0x91, 0x3D, 0x4D, @@ -1062,7 +1062,7 @@ public static partial class Apis 0x00, 0x4A, 0xA1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1074,7 +1074,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBD, 0xA6, 0x78, 0x7B, 0x41, 0x01, 0xEF, 0x4D, @@ -1086,7 +1086,7 @@ public static partial class Apis 0x0C, 0xBD, 0xD5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1098,7 +1098,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0x1F, 0xC0, 0x74, 0x0D, 0x2A, 0x8C, 0x40, @@ -1110,7 +1110,7 @@ public static partial class Apis 0x19, 0x77, 0x42 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1122,7 +1122,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2B, 0xEB, 0xC5, 0xB1, 0x48, 0x03, 0xF0, 0x43, @@ -1134,7 +1134,7 @@ public static partial class Apis 0xCB, 0xA2, 0xAE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1146,7 +1146,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFA, 0x8C, 0x6C, 0xB5, 0x34, 0xF6, 0xEE, 0x41, @@ -1158,7 +1158,7 @@ public static partial class Apis 0x10, 0x60, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1170,7 +1170,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEB, 0xE0, 0xDD, 0x36, 0x25, 0x37, 0xE0, 0x42, @@ -1182,7 +1182,7 @@ public static partial class Apis 0xAE, 0xE6, 0x44 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1194,7 +1194,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4D, 0x78, 0xC3, 0xE0, 0x39, 0xCB, 0x84, 0x4E, @@ -1206,7 +1206,7 @@ public static partial class Apis 0x81, 0x02, 0x63 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1218,7 +1218,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5E, 0x94, 0x88, 0x21, 0xA3, 0x33, 0x66, 0x43, @@ -1230,7 +1230,7 @@ public static partial class Apis 0x2D, 0x08, 0x84 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1242,7 +1242,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x10, 0xF4, 0x1A, 0x3A, 0x1D, 0x5F, 0xBE, 0x4D, @@ -1254,7 +1254,7 @@ public static partial class Apis 0x9B, 0x71, 0x53 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1266,7 +1266,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCB, 0x87, 0xB8, 0xC9, 0xFF, 0xC5, 0xC5, 0x4D, @@ -1278,7 +1278,7 @@ public static partial class Apis 0x41, 0x7C, 0x7D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1290,7 +1290,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x12, 0x7B, 0xA4, 0x4D, 0xA3, 0x79, 0xB0, 0x4F, @@ -1302,7 +1302,7 @@ public static partial class Apis 0xA4, 0xDE, 0x08 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1314,7 +1314,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x87, 0x60, 0x17, 0x89, 0xF9, 0x8A, 0x08, 0x4A, @@ -1326,7 +1326,7 @@ public static partial class Apis 0xDB, 0x17, 0x66 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1338,7 +1338,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBE, 0x40, 0x0C, 0xC0, 0x67, 0x5E, 0xA3, 0x4C, @@ -1350,7 +1350,7 @@ public static partial class Apis 0x11, 0x51, 0x35 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1362,7 +1362,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0x83, 0xF5, 0xEF, 0x07, 0xCB, 0xA9, 0x4A, @@ -1374,7 +1374,7 @@ public static partial class Apis 0x76, 0x46, 0x0F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1386,7 +1386,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x84, 0x83, 0xDC, 0xCA, 0x3F, 0x32, 0x7E, 0x4C, @@ -1398,7 +1398,7 @@ public static partial class Apis 0xDF, 0x6E, 0xE4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1410,7 +1410,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x0E, 0x9E, 0x34, 0x88, 0x00, 0x79, 0x4A, @@ -1422,7 +1422,7 @@ public static partial class Apis 0x20, 0x20, 0x20 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1434,7 +1434,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0x79, 0x1D, 0x81, 0x28, 0xDE, 0x54, 0x44, @@ -1446,7 +1446,7 @@ public static partial class Apis 0xF8, 0xBD, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1458,7 +1458,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF0, 0xCF, 0x0E, 0xC8, 0xD5, 0x3F, 0x05, 0x4F, @@ -1470,7 +1470,7 @@ public static partial class Apis 0x4B, 0x4F, 0x0A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1482,7 +1482,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE8, 0x75, 0xF5, 0x12, 0xB1, 0x4D, 0x5F, 0x48, @@ -1494,7 +1494,7 @@ public static partial class Apis 0xD3, 0x82, 0x9F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1506,7 +1506,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x17, 0x2B, 0x31, 0x36, 0xDD, 0xF7, 0x14, 0x40, @@ -1518,7 +1518,7 @@ public static partial class Apis 0x8C, 0xF2, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1532,7 +1532,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0xCA, 0xA1, 0x44, 0xDD, 0x6C, 0x18, 0x48, @@ -1544,7 +1544,7 @@ public static partial class Apis 0xE9, 0x5B, 0xDB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1556,7 +1556,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8D, 0x74, 0x0B, 0x7B, 0x10, 0x46, 0x86, 0x44, @@ -1568,7 +1568,7 @@ public static partial class Apis 0x2E, 0x2B, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1AnalysisTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1AnalysisTransform.cs index 2910c5a..59a50d5 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1AnalysisTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1AnalysisTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1AnalysisTransform : ID2D1AnalysisTransform.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x30, 0xDC, 0x59, 0x03, 0xE6, 0x95, 0x68, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1AnalysisTransform : ID2D1AnalysisTransform.Int 0x13, 0x0E, 0x93 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap.cs index f8ba593..4cd6e3a 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Bitmap : ID2D1Bitmap.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x57, 0x60, 0x29, 0xA2, 0x42, 0xEA, 0x99, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Bitmap : ID2D1Bitmap.Interface, INativeGuid 0x50, 0x54, 0x26 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap1.cs index 59967ee..a5bf9e4 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Bitmap1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Bitmap1 : ID2D1Bitmap1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4C, 0xA8, 0x98, 0xA8, 0x73, 0x38, 0x88, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Bitmap1 : ID2D1Bitmap1.Interface, INativeGuid 0x8D, 0xF0, 0x41 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush.cs index a52486b..bfbb009 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1BitmapBrush : ID2D1BitmapBrush.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1BitmapBrush : ID2D1BitmapBrush.Interface, INat 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush1.cs index e44c5eb..2233327 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapBrush1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1BitmapBrush1 : ID2D1BitmapBrush1.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x53, 0x3A, 0x34, 0x41, 0x1A, 0xE4, 0xA2, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1BitmapBrush1 : ID2D1BitmapBrush1.Interface, IN 0xBB, 0x62, 0xE5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapRenderTarget.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapRenderTarget.cs index 8a95905..d99ef0e 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapRenderTarget.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BitmapRenderTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1BitmapRenderTarget : ID2D1BitmapRenderTarget.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x95, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1BitmapRenderTarget : ID2D1BitmapRenderTarget.I 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BlendTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BlendTransform.cs index 1fcacd5..5ee6955 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BlendTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BlendTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1BlendTransform : ID2D1BlendTransform.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x32, 0x0B, 0xAC, 0x63, 0x44, 0xBA, 0x0F, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1BlendTransform : ID2D1BlendTransform.Interface 0xFF, 0x2F, 0x1B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BorderTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BorderTransform.cs index e6524e0..9f08b43 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BorderTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BorderTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1BorderTransform : ID2D1BorderTransform.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5C, 0x73, 0x98, 0x49, 0x19, 0x3A, 0x3C, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1BorderTransform : ID2D1BorderTransform.Interfa 0xE3, 0xA3, 0x47 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BoundsAdjustmentTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BoundsAdjustmentTransform.cs index 2b29478..9ff43bf 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BoundsAdjustmentTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1BoundsAdjustmentTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1BoundsAdjustmentTransform : ID2D1BoundsAdjustm [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE2, 0x32, 0xF7, 0x90, 0x92, 0x50, 0x06, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1BoundsAdjustmentTransform : ID2D1BoundsAdjustm 0x0B, 0xAC, 0xCD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Brush.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Brush.cs index 01e906e..555a431 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Brush.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Brush.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Brush : ID2D1Brush.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA8, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Brush : ID2D1Brush.Interface, INativeGuid 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext.cs index 550d188..2a4c48b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ColorContext : ID2D1ColorContext.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBB, 0x20, 0x48, 0x1C, 0x71, 0x57, 0x18, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ColorContext : ID2D1ColorContext.Interface, IN 0x0E, 0xC6, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext1.cs index da7a47c..7e2eef3 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ColorContext1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ColorContext1 : ID2D1ColorContext1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x75, 0x28, 0xB4, 0x1A, 0x7F, 0xC5, 0xE9, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ColorContext1 : ID2D1ColorContext1.Interface, 0x6F, 0x55, 0xEE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandList.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandList.cs index d865265..9442942 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandList.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandList.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandList : ID2D1CommandList.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0x4A, 0xF3, 0xB4, 0x83, 0x23, 0x76, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandList : ID2D1CommandList.Interface, INat 0x57, 0xC3, 0xDC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink.cs index 4d41358..604ae02 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandSink : ID2D1CommandSink.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0x89, 0xD7, 0x54, 0x61, 0xA0, 0xA7, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandSink : ID2D1CommandSink.Interface, INat 0xBA, 0x2C, 0x4F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink1.cs index 7a74074..3dc0489 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandSink1 : ID2D1CommandSink1.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFD, 0x67, 0xB7, 0x9E, 0x69, 0x42, 0x67, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandSink1 : ID2D1CommandSink1.Interface, IN 0x30, 0x57, 0x43 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink2.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink2.cs index 930d5c8..0789234 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink2.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandSink2 : ID2D1CommandSink2.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0E, 0x44, 0xAB, 0x3B, 0x7E, 0x41, 0xDF, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandSink2 : ID2D1CommandSink2.Interface, IN 0xA0, 0x09, 0x16 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink3.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink3.cs index 1e5da82..1631f47 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink3.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandSink3 : ID2D1CommandSink3.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x35, 0x91, 0x07, 0x18, 0xF3, 0x4C, 0x68, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandSink3 : ID2D1CommandSink3.Interface, IN 0x6D, 0x24, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink4.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink4.cs index d99fef6..9b5dd7b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink4.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandSink4 : ID2D1CommandSink4.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0x65, 0x8A, 0xC7, 0xD6, 0x40, 0x18, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandSink4 : ID2D1CommandSink4.Interface, IN 0x44, 0xBB, 0x3E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink5.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink5.cs index 819e2ed..7c9aa09 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink5.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1CommandSink5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1CommandSink5 : ID2D1CommandSink5.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x26, 0xDD, 0x47, 0x70, 0xE7, 0xB1, 0xA7, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1CommandSink5 : ID2D1CommandSink5.Interface, IN 0x14, 0x4F, 0xA8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeInfo.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeInfo.cs index 92f7119..49211ee 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeInfo.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ComputeInfo : ID2D1ComputeInfo.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4B, 0xB1, 0x98, 0x55, 0xD7, 0x9F, 0xB7, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ComputeInfo : ID2D1ComputeInfo.Interface, INat 0xEB, 0x38, 0xBC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeTransform.cs index d07dc0c..79f1a39 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ComputeTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ComputeTransform : ID2D1ComputeTransform.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3C, 0x57, 0x85, 0x0D, 0xE3, 0x01, 0x7D, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ComputeTransform : ID2D1ComputeTransform.Inter 0x8B, 0xF3, 0xC3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ConcreteTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ConcreteTransform.cs index fa5a7fa..c617598 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ConcreteTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ConcreteTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ConcreteTransform : ID2D1ConcreteTransform.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0x9D, 0x79, 0x1A, 0xF7, 0x69, 0x4C, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ConcreteTransform : ID2D1ConcreteTransform.Int 0x66, 0x84, 0xCC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DCRenderTarget.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DCRenderTarget.cs index 1bf9545..592bb73 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DCRenderTarget.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DCRenderTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DCRenderTarget : ID2D1DCRenderTarget.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x64, 0xBC, 0x51, 0x1C, 0x61, 0xDE, 0xFD, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DCRenderTarget : ID2D1DCRenderTarget.Interface 0xF0, 0x39, 0x50 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device.cs index 926c1e3..ae241d8 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device : ID2D1Device.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5D, 0x57, 0xDD, 0x47, 0x05, 0xAC, 0xDD, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device : ID2D1Device.Interface, INativeGuid 0x16, 0xF4, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device1.cs index e02a4de..a1779d3 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device1 : ID2D1Device1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE1, 0x68, 0x17, 0xD2, 0xA4, 0x23, 0x23, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device1 : ID2D1Device1.Interface, INativeGuid 0x85, 0xD6, 0x58 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device2.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device2.cs index 93fed1d..ccf31df 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device2.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device2 : ID2D1Device2.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE1, 0x72, 0x44, 0xA4, 0xFB, 0x8D, 0x60, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device2 : ID2D1Device2.Interface, INativeGuid 0xC9, 0xCA, 0x8B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device3.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device3.cs index 629f3cf..00c3bfd 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device3.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device3 : ID2D1Device3.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x87, 0x20, 0x2F, 0x85, 0x2C, 0x80, 0x37, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device3 : ID2D1Device3.Interface, INativeGuid 0xE6, 0xFC, 0x01 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device4.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device4.cs index 863d1cc..0606ee6 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device4.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device4 : ID2D1Device4.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x59, 0xB1, 0xBD, 0xD7, 0x83, 0x56, 0x46, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device4 : ID2D1Device4.Interface, INativeGuid 0x0B, 0x85, 0x8B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device5.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device5.cs index 6782a40..f0538c1 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device5.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device5 : ID2D1Device5.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0xA0, 0x5B, 0xD5, 0x05, 0x64, 0x94, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device5 : ID2D1Device5.Interface, INativeGuid 0x43, 0x58, 0xB4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device6.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device6.cs index c4771c2..f7fecc4 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device6.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device6.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device6 : ID2D1Device6.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x14, 0xF9, 0xFE, 0x7B, 0x75, 0x2D, 0xAD, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device6 : ID2D1Device6.Interface, INativeGuid 0x07, 0x7B, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device7.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device7.cs index f01e66c..d2e99c5 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device7.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Device7.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Device7 : ID2D1Device7.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x68, 0x89, 0x7C, 0xF0, 0x4E, 0xDD, 0xA6, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Device7 : ID2D1Device7.Interface, INativeGuid 0x52, 0xDC, 0xBB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext.cs index 279c09b..a688002 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext : ID2D1DeviceContext.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7A, 0xFE, 0xF7, 0xE8, 0x1C, 0x19, 0x6D, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext : ID2D1DeviceContext.Interface, 0xBD, 0xA9, 0x98 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext1.cs index d919efe..cfd6544 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext1 : ID2D1DeviceContext1.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE4, 0x57, 0x7F, 0xD3, 0x08, 0x69, 0x9F, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext1 : ID2D1DeviceContext1.Interface 0xF7, 0x99, 0x87 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext2.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext2.cs index 7227abb..3a3027f 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext2.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext2 : ID2D1DeviceContext2.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA3, 0xA6, 0x4E, 0x39, 0x34, 0x0C, 0x21, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext2 : ID2D1DeviceContext2.Interface 0x0B, 0xE6, 0xC7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext3.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext3.cs index 1b12db7..e706727 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext3.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext3 : ID2D1DeviceContext3.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x96, 0x74, 0x5A, 0x23, 0x51, 0x83, 0x4C, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext3 : ID2D1DeviceContext3.Interface 0x2D, 0x8E, 0x00 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext4.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext4.cs index 96e277f..9a31862 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext4.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext4 : ID2D1DeviceContext4.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x31, 0x78, 0x42, 0x8C, 0x90, 0x3D, 0x76, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext4 : ID2D1DeviceContext4.Interface 0x49, 0xE4, 0xDB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext5.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext5.cs index 6fe9245..288e4bb 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext5.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext5 : ID2D1DeviceContext5.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x48, 0xD2, 0x36, 0x78, 0xCC, 0x68, 0xF6, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext5 : ID2D1DeviceContext5.Interface 0xF6, 0x2E, 0xB7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext6.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext6.cs index 303464f..1ac6061 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext6.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext6.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext6 : ID2D1DeviceContext6.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0x7E, 0x5F, 0x98, 0xD0, 0x4E, 0x19, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext6 : ID2D1DeviceContext6.Interface 0xFD, 0xE3, 0x06 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext7.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext7.cs index 6efee4c..37cccfc 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext7.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DeviceContext7.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DeviceContext7 : ID2D1DeviceContext7.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF7, 0x1C, 0x89, 0xEC, 0x69, 0x9B, 0x51, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DeviceContext7 : ID2D1DeviceContext7.Interface 0x77, 0x1E, 0x62 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawInfo.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawInfo.cs index 689ec70..f4ea23d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawInfo.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DrawInfo : ID2D1DrawInfo.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x32, 0xE6, 0x3C, 0x69, 0x2F, 0x7F, 0xDE, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DrawInfo : ID2D1DrawInfo.Interface, INativeGui 0x37, 0xAA, 0x21 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawTransform.cs index b0dfd89..ce4367e 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DrawTransform : ID2D1DrawTransform.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB6, 0xDC, 0xBF, 0x36, 0x39, 0x97, 0x5D, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DrawTransform : ID2D1DrawTransform.Interface, 0xFF, 0x6A, 0x6F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock.cs index fd3b4ee..37b2278 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DrawingStateBlock : ID2D1DrawingStateBlock.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x39, 0x6E, 0x50, 0x28, 0xF6, 0xEB, 0xA1, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DrawingStateBlock : ID2D1DrawingStateBlock.Int 0x5A, 0xB9, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock1.cs index 50fcf9e..ade3b1d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1DrawingStateBlock1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1DrawingStateBlock1 : ID2D1DrawingStateBlock1.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0x1F, 0x9F, 0x68, 0x2E, 0xC7, 0x33, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1DrawingStateBlock1 : ID2D1DrawingStateBlock1.I 0xFD, 0x5A, 0xCE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Effect.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Effect.cs index a130d52..8b10d72 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Effect.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Effect.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Effect : ID2D1Effect.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x43, 0x1A, 0x21, 0x28, 0x89, 0x7D, 0x6F, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Effect : ID2D1Effect.Interface, INativeGuid 0xB2, 0x20, 0xAD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext.cs index ba34bc5..01a32a6 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1EffectContext : ID2D1EffectContext.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6B, 0x91, 0x9F, 0x3D, 0xDC, 0x27, 0xD7, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1EffectContext : ID2D1EffectContext.Interface, 0x40, 0xF5, 0x63 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext1.cs index 5807000..3a4ffbe 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1EffectContext1 : ID2D1EffectContext1.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5A, 0x59, 0xAB, 0x84, 0x81, 0xFC, 0x46, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1EffectContext1 : ID2D1EffectContext1.Interface 0x8A, 0xBE, 0x7A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext2.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext2.cs index 6a0cb1a..0269155 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext2.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectContext2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1EffectContext2 : ID2D1EffectContext2.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA0, 0xD2, 0x7A, 0x57, 0xC7, 0x9F, 0xDA, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1EffectContext2 : ID2D1EffectContext2.Interface 0x14, 0x00, 0x52 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectImpl.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectImpl.cs index d49e986..c0472d3 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectImpl.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EffectImpl.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1EffectImpl : ID2D1EffectImpl.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3F, 0xFD, 0x48, 0xA2, 0x6C, 0x3E, 0x63, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1EffectImpl : ID2D1EffectImpl.Interface, INativ 0xC9, 0x1D, 0xB9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EllipseGeometry.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EllipseGeometry.cs index 9175f09..a953252 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EllipseGeometry.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1EllipseGeometry.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1EllipseGeometry : ID2D1EllipseGeometry.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1EllipseGeometry : ID2D1EllipseGeometry.Interfa 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory.cs index 8ae717e..c730e19 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory : ID2D1Factory.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x47, 0x22, 0x15, 0x06, 0x50, 0x6F, 0x5A, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory : ID2D1Factory.Interface, INativeGuid 0x3B, 0x60, 0x07 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory1.cs index 4ab3ed7..5b70f06 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory1 : ID2D1Factory1.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0xD3, 0x12, 0xBB, 0xEE, 0xDA, 0x9A, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory1 : ID2D1Factory1.Interface, INativeGui 0x1C, 0xFA, 0x1F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory2.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory2.cs index 07ceb66..366a40d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory2.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory2 : ID2D1Factory2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x73, 0x1A, 0xF8, 0x94, 0x12, 0x92, 0x76, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory2 : ID2D1Factory2.Interface, INativeGui 0x0D, 0x39, 0x92 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory3.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory3.cs index b38af63..4f616f3 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory3.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory3 : ID2D1Factory3.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0x75, 0x69, 0x08, 0x00, 0x4F, 0x3F, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory3 : ID2D1Factory3.Interface, INativeGui 0x40, 0x4D, 0x0F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory4.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory4.cs index c2fa8fc..ae10ba3 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory4.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory4 : ID2D1Factory4.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD2, 0xC2, 0x4E, 0xBD, 0x62, 0x06, 0xEE, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory4 : ID2D1Factory4.Interface, INativeGui 0x32, 0xE0, 0x96 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory5.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory5.cs index 0f41c82..baa2348 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory5.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory5 : ID2D1Factory5.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x94, 0x99, 0x34, 0xC4, 0x8E, 0x83, 0x0F, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory5 : ID2D1Factory5.Interface, INativeGui 0x9E, 0xEA, 0xCC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory6.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory6.cs index dd48a15..3eafa6b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory6.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory6.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory6 : ID2D1Factory6.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x46, 0x6F, 0x97, 0xF9, 0x42, 0xF6, 0xC1, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory6 : ID2D1Factory6.Interface, INativeGui 0x2A, 0x26, 0x35 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory7.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory7.cs index 8b131e5..e72b77d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory7.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory7.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory7 : ID2D1Factory7.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD3, 0xBD, 0xC2, 0xBD, 0x6C, 0xB9, 0xE6, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory7 : ID2D1Factory7.Interface, INativeGui 0x54, 0x54, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory8.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory8.cs index 2261553..f4555ec 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory8.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Factory8.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Factory8 : ID2D1Factory8.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x11, 0x93, 0x7C, 0x67, 0x6D, 0xF3, 0x1F, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Factory8 : ID2D1Factory8.Interface, INativeGui 0x3F, 0xFD, 0x3A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiInteropRenderTarget.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiInteropRenderTarget.cs index e21493e..2f3a4fc 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiInteropRenderTarget.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiInteropRenderTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GdiInteropRenderTarget : ID2D1GdiInteropRender [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x51, 0xDB, 0xE0, 0x77, 0x6F, 0xAE, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GdiInteropRenderTarget : ID2D1GdiInteropRender 0xB3, 0x58, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile.cs index ccd1904..64b6a53 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GdiMetafile : ID2D1GdiMetafile.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x3D, 0x54, 0x2F, 0xC1, 0xCF, 0x11, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GdiMetafile : ID2D1GdiMetafile.Interface, INat 0x6F, 0x33, 0x95 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile1.cs index 39689d1..9fe23a8 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafile1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GdiMetafile1 : ID2D1GdiMetafile1.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE8, 0xF9, 0x69, 0x2E, 0x3F, 0xDD, 0xF9, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GdiMetafile1 : ID2D1GdiMetafile1.Interface, IN 0xD7, 0x88, 0xDF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink.cs index 38e79d6..0c3c98b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GdiMetafileSink : ID2D1GdiMetafileSink.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x26, 0x73, 0x23, 0x82, 0x11, 0x81, 0x7C, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GdiMetafileSink : ID2D1GdiMetafileSink.Interfa 0x55, 0x64, 0xFE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink1.cs index eec9dc6..450d915 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GdiMetafileSink1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GdiMetafileSink1 : ID2D1GdiMetafileSink1.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6B, 0xCB, 0x0E, 0xFD, 0xE6, 0x91, 0x1E, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GdiMetafileSink1 : ID2D1GdiMetafileSink1.Inter 0x0F, 0x91, 0xB4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Geometry.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Geometry.cs index 72a19bb..d092319 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Geometry.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Geometry.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Geometry : ID2D1Geometry.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA1, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Geometry : ID2D1Geometry.Interface, INativeGui 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryGroup.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryGroup.cs index a279fb8..1c7b9b9 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryGroup.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryGroup.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GeometryGroup : ID2D1GeometryGroup.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GeometryGroup : ID2D1GeometryGroup.Interface, 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryRealization.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryRealization.cs index 8898bee..8f117f4 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryRealization.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometryRealization.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GeometryRealization : ID2D1GeometryRealization [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD7, 0x07, 0x69, 0xA1, 0x02, 0xBC, 0x01, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GeometryRealization : ID2D1GeometryRealization 0x85, 0xF7, 0x74 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometrySink.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometrySink.cs index cebda9e..5cf6b5f 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometrySink.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GeometrySink.cs @@ -23,7 +23,7 @@ public unsafe partial struct ID2D1GeometrySink : ID2D1GeometrySink.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -35,7 +35,7 @@ public unsafe partial struct ID2D1GeometrySink : ID2D1GeometrySink.Interface, IN 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientMesh.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientMesh.cs index ed1d868..4da501e 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientMesh.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientMesh.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GradientMesh : ID2D1GradientMesh.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0xE4, 0x92, 0xF2, 0x50, 0xC0, 0xDE, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GradientMesh : ID2D1GradientMesh.Interface, IN 0x3B, 0x23, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection.cs index eff7a3f..71e8641 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GradientStopCollection : ID2D1GradientStopColl [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA7, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GradientStopCollection : ID2D1GradientStopColl 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection1.cs index 917b20b..0feebb2 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1GradientStopCollection1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1GradientStopCollection1 : ID2D1GradientStopCol [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF4, 0x72, 0x15, 0xAE, 0xD0, 0x5D, 0x77, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1GradientStopCollection1 : ID2D1GradientStopCol 0x2A, 0xE6, 0x3B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1HwndRenderTarget.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1HwndRenderTarget.cs index a074c77..641d902 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1HwndRenderTarget.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1HwndRenderTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1HwndRenderTarget : ID2D1HwndRenderTarget.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x98, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1HwndRenderTarget : ID2D1HwndRenderTarget.Inter 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Image.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Image.cs index efcfd31..1bf7f68 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Image.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Image.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Image : ID2D1Image.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x75, 0x9F, 0x01, 0x65, 0xA2, 0x8D, 0x7C, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Image : ID2D1Image.Interface, INativeGuid 0x48, 0xED, 0xE6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageBrush.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageBrush.cs index 4442340..58d03bb 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageBrush.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageBrush.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ImageBrush : ID2D1ImageBrush.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4D, 0x98, 0x9E, 0xFE, 0x95, 0x3F, 0x7C, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ImageBrush : ID2D1ImageBrush.Interface, INativ 0xE8, 0xF8, 0x7C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSource.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSource.cs index 0d1aa48..6234a99 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSource.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSource.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ImageSource : ID2D1ImageSource.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE5, 0x64, 0xB6, 0xC9, 0xA1, 0x74, 0x78, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ImageSource : ID2D1ImageSource.Interface, INat 0xA3, 0xF4, 0xD8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSourceFromWic.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSourceFromWic.cs index d07ffe0..04be97f 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSourceFromWic.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ImageSourceFromWic.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ImageSourceFromWic : ID2D1ImageSourceFromWic.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x41, 0x54, 0x39, 0x77, 0x8F, 0x1C, 0x55, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ImageSourceFromWic : ID2D1ImageSourceFromWic.I 0x0F, 0xE7, 0x92 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Ink.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Ink.cs index 0f8a72e..375f607 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Ink.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Ink.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Ink : ID2D1Ink.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3B, 0x92, 0x99, 0xB4, 0x29, 0x70, 0x8F, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Ink : ID2D1Ink.Interface, INativeGuid 0x5F, 0x53, 0x12 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1InkStyle.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1InkStyle.cs index 24bbe31..c809957 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1InkStyle.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1InkStyle.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1InkStyle : ID2D1InkStyle.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x44, 0xB3, 0xE8, 0xBA, 0xFC, 0x23, 0x71, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1InkStyle : ID2D1InkStyle.Interface, INativeGui 0x07, 0x38, 0x48 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Layer.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Layer.cs index a1a16b3..3effc67 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Layer.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Layer.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Layer : ID2D1Layer.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9B, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Layer : ID2D1Layer.Interface, INativeGuid 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LinearGradientBrush.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LinearGradientBrush.cs index 57740f0..8b4c756 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LinearGradientBrush.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LinearGradientBrush.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1LinearGradientBrush : ID2D1LinearGradientBrush [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAB, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1LinearGradientBrush : ID2D1LinearGradientBrush 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LookupTable3D.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LookupTable3D.cs index 70b8797..d9e3a6b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LookupTable3D.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1LookupTable3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1LookupTable3D : ID2D1LookupTable3D.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x55, 0x98, 0xDD, 0x53, 0xB0, 0xA3, 0x5B, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1LookupTable3D : ID2D1LookupTable3D.Interface, 0x5E, 0x57, 0x97 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Mesh.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Mesh.cs index 8ed5777..fee6cc4 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Mesh.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Mesh.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Mesh : ID2D1Mesh.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC2, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Mesh : ID2D1Mesh.Interface, INativeGuid 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Multithread.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Multithread.cs index 01bb781..d6a965b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Multithread.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Multithread.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Multithread : ID2D1Multithread.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBC, 0xE7, 0xE6, 0x31, 0xFF, 0xE0, 0x46, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Multithread : ID2D1Multithread.Interface, INat 0x1C, 0x15, 0xD3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1OffsetTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1OffsetTransform.cs index e47a23a..f6c7aa3 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1OffsetTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1OffsetTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1OffsetTransform : ID2D1OffsetTransform.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEA, 0xAD, 0xE6, 0x3F, 0x43, 0x76, 0x53, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1OffsetTransform : ID2D1OffsetTransform.Interfa 0xF2, 0x40, 0x42 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry.cs index 519c0c3..ef07158 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1PathGeometry : ID2D1PathGeometry.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA5, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1PathGeometry : ID2D1PathGeometry.Interface, IN 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry1.cs index ab20316..64b89ed 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PathGeometry1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1PathGeometry1 : ID2D1PathGeometry1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD2, 0xA2, 0xBA, 0x62, 0x54, 0xAB, 0xB7, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1PathGeometry1 : ID2D1PathGeometry1.Interface, 0x06, 0xA4, 0x21 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PrintControl.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PrintControl.cs index d9c3485..481a74c 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PrintControl.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1PrintControl.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1PrintControl : ID2D1PrintControl.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7D, 0x86, 0x1D, 0x2C, 0x90, 0xC2, 0xC8, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1PrintControl : ID2D1PrintControl.Interface, IN 0x02, 0xE9, 0xA5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Properties.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Properties.cs index 03211eb..1bde7a2 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Properties.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Properties.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Properties : ID2D1Properties.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD7, 0x73, 0x34, 0x48, 0x46, 0xCD, 0x9D, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Properties : ID2D1Properties.Interface, INativ 0x80, 0x15, 0x9D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RadialGradientBrush.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RadialGradientBrush.cs index f086d7a..9c83d2f 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RadialGradientBrush.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RadialGradientBrush.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1RadialGradientBrush : ID2D1RadialGradientBrush [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAC, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1RadialGradientBrush : ID2D1RadialGradientBrush 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RectangleGeometry.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RectangleGeometry.cs index 0a9053d..9171e40 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RectangleGeometry.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RectangleGeometry.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1RectangleGeometry : ID2D1RectangleGeometry.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1RectangleGeometry : ID2D1RectangleGeometry.Int 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderInfo.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderInfo.cs index 1908356..3668808 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderInfo.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1RenderInfo : ID2D1RenderInfo.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBD, 0xE1, 0x9A, 0x51, 0x9A, 0xD1, 0x0D, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1RenderInfo : ID2D1RenderInfo.Interface, INativ 0x47, 0x76, 0xB7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderTarget.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderTarget.cs index 42cb0a0..8419eaf 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderTarget.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RenderTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1RenderTarget : ID2D1RenderTarget.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x94, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1RenderTarget : ID2D1RenderTarget.Interface, IN 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Resource.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Resource.cs index 57d78b3..b5eae57 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Resource.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Resource.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Resource : ID2D1Resource.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x91, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Resource : ID2D1Resource.Interface, INativeGui 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ResourceTexture.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ResourceTexture.cs index fab0679..ac45879 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ResourceTexture.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1ResourceTexture.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1ResourceTexture : ID2D1ResourceTexture.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x15, 0x8D, 0x68, 0xB0, 0x02, 0x8D, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1ResourceTexture : ID2D1ResourceTexture.Interfa 0x32, 0xC3, 0x9A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RoundedRectangleGeometry.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RoundedRectangleGeometry.cs index 12c92f4..f6ef628 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RoundedRectangleGeometry.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1RoundedRectangleGeometry.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1RoundedRectangleGeometry : ID2D1RoundedRectang [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA3, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1RoundedRectangleGeometry : ID2D1RoundedRectang 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SolidColorBrush.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SolidColorBrush.cs index dfb6304..d94cecf 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SolidColorBrush.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SolidColorBrush.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SolidColorBrush : ID2D1SolidColorBrush.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA9, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SolidColorBrush : ID2D1SolidColorBrush.Interfa 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SourceTransform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SourceTransform.cs index e2d732f..0844c64 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SourceTransform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SourceTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SourceTransform : ID2D1SourceTransform.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDD, 0x00, 0x18, 0xDB, 0x34, 0x0C, 0xF9, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SourceTransform : ID2D1SourceTransform.Interfa 0x56, 0x53, 0xE1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SpriteBatch.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SpriteBatch.cs index 7ba5367..e4bcd6a 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SpriteBatch.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SpriteBatch.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SpriteBatch : ID2D1SpriteBatch.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBF, 0x83, 0xC5, 0x4D, 0x10, 0x3A, 0x8A, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SpriteBatch : ID2D1SpriteBatch.Interface, INat 0x24, 0xF1, 0xF1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle.cs index 35fc22d..2f73f8d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1StrokeStyle : ID2D1StrokeStyle.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9D, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1StrokeStyle : ID2D1StrokeStyle.Interface, INat 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle1.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle1.cs index ddb665c..518ab91 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle1.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1StrokeStyle1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1StrokeStyle1 : ID2D1StrokeStyle1.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0x2A, 0xA7, 0x10, 0x1C, 0xE9, 0xF4, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1StrokeStyle1 : ID2D1StrokeStyle1.Interface, IN 0x2B, 0x0B, 0x4A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgAttribute.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgAttribute.cs index b2694a6..f177184 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgAttribute.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgAttribute.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgAttribute : ID2D1SvgAttribute.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDD, 0xB0, 0xCD, 0xC9, 0xC9, 0xF8, 0x70, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgAttribute : ID2D1SvgAttribute.Interface, IN 0x29, 0x2C, 0x5E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgDocument.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgDocument.cs index 2209d9f..17ebe6d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgDocument.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgDocument.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgDocument : ID2D1SvgDocument.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4D, 0x8E, 0xB8, 0x86, 0xA4, 0xAF, 0x7B, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgDocument : ID2D1SvgDocument.Interface, INat 0x4A, 0x0A, 0xEC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgElement.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgElement.cs index 5486e76..acce254 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgElement.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgElement.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgElement : ID2D1SvgElement.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0x67, 0x7B, 0xAC, 0x3E, 0x18, 0xC1, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgElement : ID2D1SvgElement.Interface, INativ 0xB0, 0xDB, 0x29 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgGlyphStyle.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgGlyphStyle.cs index cc0fd56..bc40854 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgGlyphStyle.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgGlyphStyle.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgGlyphStyle : ID2D1SvgGlyphStyle.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x49, 0x17, 0x67, 0xAF, 0x41, 0xD2, 0xB8, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgGlyphStyle : ID2D1SvgGlyphStyle.Interface, 0xC1, 0xA4, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPaint.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPaint.cs index e834e7e..3dffc8c 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPaint.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPaint.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgPaint : ID2D1SvgPaint.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0A, 0xAB, 0x9B, 0xD5, 0xA2, 0x68, 0x5B, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgPaint : ID2D1SvgPaint.Interface, INativeGui 0x4E, 0x24, 0x90 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPathData.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPathData.cs index 4652ebb..bc7940b 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPathData.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPathData.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgPathData : ID2D1SvgPathData.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF4, 0xE4, 0x95, 0xC0, 0x98, 0xBB, 0xD6, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgPathData : ID2D1SvgPathData.Interface, INat 0xEC, 0x98, 0x88 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPointCollection.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPointCollection.cs index 03f85e0..14242c9 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPointCollection.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgPointCollection.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgPointCollection : ID2D1SvgPointCollection.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0D, 0x4C, 0xBE, 0x9D, 0x72, 0x35, 0xD9, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgPointCollection : ID2D1SvgPointCollection.I 0x3B, 0xB7, 0x12 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgStrokeDashArray.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgStrokeDashArray.cs index 1e4ac42..2d0b84d 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgStrokeDashArray.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1SvgStrokeDashArray.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1SvgStrokeDashArray : ID2D1SvgStrokeDashArray.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x52, 0xCA, 0xC0, 0xF1, 0xA3, 0x92, 0x00, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1SvgStrokeDashArray : ID2D1SvgStrokeDashArray.I 0xEF, 0xD9, 0xD9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TessellationSink.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TessellationSink.cs index da830bb..f5196b9 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TessellationSink.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TessellationSink.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1TessellationSink : ID2D1TessellationSink.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC1, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1TessellationSink : ID2D1TessellationSink.Inter 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Transform.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Transform.cs index a670c32..4eeb6e0 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Transform.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1Transform.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1Transform : ID2D1Transform.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7D, 0x28, 0x1A, 0xEF, 0x2A, 0x34, 0x76, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1Transform : ID2D1Transform.Interface, INativeG 0xA9, 0xF9, 0x2B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformGraph.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformGraph.cs index 72bc5c4..1a037f4 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformGraph.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformGraph.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1TransformGraph : ID2D1TransformGraph.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x38, 0x90, 0xD2, 0x13, 0xE6, 0xC3, 0x34, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1TransformGraph : ID2D1TransformGraph.Interface 0x41, 0x79, 0x92 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformNode.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformNode.cs index 257c432..b2b022f 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformNode.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformNode.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1TransformNode : ID2D1TransformNode.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE7, 0xE1, 0xEF, 0xB2, 0x9F, 0x72, 0x02, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1TransformNode : ID2D1TransformNode.Interface, 0x1B, 0xF6, 0x66 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedGeometry.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedGeometry.cs index 18657db..f23d801 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedGeometry.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedGeometry.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1TransformedGeometry : ID2D1TransformedGeometry [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBB, 0x06, 0xD9, 0x2C, 0xE2, 0x12, 0xDC, 0x11, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1TransformedGeometry : ID2D1TransformedGeometry 0xA0, 0x55, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedImageSource.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedImageSource.cs index 724ded3..7355799 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedImageSource.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1TransformedImageSource.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1TransformedImageSource : ID2D1TransformedImage [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE5, 0x79, 0x1F, 0x7F, 0x96, 0x27, 0x6C, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1TransformedImageSource : ID2D1TransformedImage 0x14, 0x45, 0xE5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1VertexBuffer.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1VertexBuffer.cs index 3100992..576ec62 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1VertexBuffer.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/ID2D1VertexBuffer.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID2D1VertexBuffer : ID2D1VertexBuffer.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0x13, 0x8B, 0x9B, 0xA5, 0x00, 0x68, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID2D1VertexBuffer : ID2D1VertexBuffer.Interface, IN 0xBF, 0x9B, 0x7B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImageEncoder.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImageEncoder.cs index 8e01356..7c344ac 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImageEncoder.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImageEncoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICImageEncoder : IWICImageEncoder.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF8, 0x5B, 0xC7, 0x04, 0xE1, 0x3C, 0x3B, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IWICImageEncoder : IWICImageEncoder.Interface, INat 0xE9, 0x49, 0x99 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImagingFactory2.cs b/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImagingFactory2.cs index a4ae512..2adda92 100644 --- a/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImagingFactory2.cs +++ b/src/Vortice.Win32.Graphics.Direct2D/Generated/IWICImagingFactory2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICImagingFactory2 : IWICImagingFactory2.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x45, 0x6B, 0x81, 0x7B, 0x96, 0x19, 0x76, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IWICImagingFactory2 : IWICImagingFactory2.Interface 0x7C, 0x8A, 0xF0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Apis.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Apis.cs index 7a2dc86..01a5c62 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Apis.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Apis.cs @@ -16,7 +16,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAF, 0xD6, 0x45, 0x62, 0xE0, 0x66, 0xFD, 0x48, @@ -28,7 +28,7 @@ public static partial class Apis 0x96, 0x74, 0x8C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -82,7 +82,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x93, 0x2D, 0xE2, 0x73, 0xCE, 0xE6, 0xF3, 0x47, @@ -94,7 +94,7 @@ public static partial class Apis 0x39, 0xC1, 0xB0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -106,7 +106,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x87, 0x80, 0x6A, 0xEF, 0xEA, 0xB0, 0x56, 0x4D, @@ -118,7 +118,7 @@ public static partial class Apis 0x8B, 0x78, 0x06 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -130,7 +130,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x73, 0x6B, 0x1F, 0xCD, 0xB0, 0x2A, 0x4D, 0x48, @@ -142,7 +142,7 @@ public static partial class Apis 0x3C, 0xA0, 0x9F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -154,7 +154,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x82, 0xAE, 0x56, 0x3E, 0x4D, 0x22, 0x0F, 0x47, @@ -166,7 +166,7 @@ public static partial class Apis 0xEE, 0x9F, 0x9D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -178,7 +178,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAF, 0xD6, 0x45, 0x62, 0xE0, 0x66, 0xFD, 0x48, @@ -190,7 +190,7 @@ public static partial class Apis 0x96, 0x74, 0x8C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -202,7 +202,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x15, 0xE2, 0xA3, 0x8C, 0x28, 0xF7, 0xF3, 0x4C, @@ -214,7 +214,7 @@ public static partial class Apis 0x75, 0x87, 0xA1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -226,7 +226,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x68, 0xDB, 0x28, 0xD7, 0x03, 0xF9, 0x80, 0x4F, @@ -238,7 +238,7 @@ public static partial class Apis 0xEC, 0x71, 0x51 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -250,7 +250,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x89, 0x44, 0xF5, 0xB9, 0xB8, 0x55, 0x0C, 0x40, @@ -262,7 +262,7 @@ public static partial class Apis 0x72, 0x8B, 0x91 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -274,7 +274,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0xD7, 0x2C, 0xAE, 0x22, 0xCC, 0x3F, 0x45, @@ -286,7 +286,7 @@ public static partial class Apis 0xA5, 0x20, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -298,7 +298,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x94, 0x42, 0x13, 0x94, 0x1F, 0x41, 0x74, 0x45, @@ -310,7 +310,7 @@ public static partial class Apis 0x52, 0x40, 0xD2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -322,7 +322,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFB, 0x1D, 0x62, 0x54, 0xCE, 0xF2, 0x7E, 0x45, @@ -334,7 +334,7 @@ public static partial class Apis 0xAE, 0xEC, 0x7C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -344,6 +344,8 @@ public static partial class Apis public const DxcCp DXC_CP_ACP = DxcCp.Acp; public const DxcCp DXC_CP_UTF16 = DxcCp.Utf16; public const DxcCp DXC_CP_UTF8 = DxcCp.Utf8; + public const DxcCp DXC_CP_UTF32 = DxcCp.Utf32; + public const DxcCp DXC_CP_WIDE = DxcCp.Wide; public const DxcOutKind DXC_OUT_NONE = DxcOutKind.None; public const DxcOutKind DXC_OUT_OBJECT = DxcOutKind.Object; public const DxcOutKind DXC_OUT_ERRORS = DxcOutKind.Errors; @@ -355,6 +357,11 @@ public static partial class Apis public const DxcOutKind DXC_OUT_REFLECTION = DxcOutKind.Reflection; public const DxcOutKind DXC_OUT_ROOT_SIGNATURE = DxcOutKind.RootSignature; public const DxcOutKind DXC_OUT_EXTRA_OUTPUTS = DxcOutKind.ExtraOutputs; + public const DxcOutKind DXC_OUT_REMARKS = DxcOutKind.Remarks; + public const DxcOutKind DXC_OUT_TIME_REPORT = DxcOutKind.TimeReport; + public const DxcOutKind DXC_OUT_TIME_TRACE = DxcOutKind.TimeTrace; + public const DxcOutKind DXC_OUT_LAST = DxcOutKind.Last; + public const DxcOutKind DXC_OUT_NUM_ENUMS = DxcOutKind.NumEnums; public const DxcHashFlags DXC_HASHFLAG_INCLUDES_SOURCE = DxcHashFlags.IncludesSource; public const DxcValidatorFlags DxcValidatorFlags_Default = DxcValidatorFlags.Default; public const DxcValidatorFlags DxcValidatorFlags_InPlaceEdit = DxcValidatorFlags.InPlaceEdit; diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Enums.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Enums.cs index f272fed..217d280 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Enums.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/Graphics.Direct3D.Dxc.Enums.cs @@ -18,6 +18,10 @@ public enum DxcCp : uint Utf16 = 1200, /// DXC_CP_UTF8 Utf8 = 65001, + /// DXC_CP_UTF32 + Utf32 = 12000, + /// DXC_CP_WIDE + Wide = 1200, } /// DXC_OUT_KIND @@ -45,6 +49,16 @@ public enum DxcOutKind RootSignature = 9, /// DXC_OUT_EXTRA_OUTPUTS ExtraOutputs = 10, + /// DXC_OUT_REMARKS + Remarks = 11, + /// DXC_OUT_TIME_REPORT + TimeReport = 12, + /// DXC_OUT_TIME_TRACE + TimeTrace = 13, + /// DXC_OUT_LAST + Last = 13, + /// DXC_OUT_NUM_ENUMS + NumEnums = 14, } /// DXC_HASHFLAG [Flags] diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcAssembler.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcAssembler.cs index 308651c..3eb1e5f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcAssembler.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcAssembler.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcAssembler : IDxcAssembler.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x26, 0x7A, 0x1F, 0x09, 0x1F, 0x1C, 0x48, 0x49, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcAssembler : IDxcAssembler.Interface, INativeGui 0xA7, 0x71, 0xD5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlob.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlob.cs index a66b02f..290b0ef 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlob.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlob.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcBlob : IDxcBlob.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x08, 0xFB, 0xA5, 0x8B, 0x95, 0x51, 0xE2, 0x40, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcBlob : IDxcBlob.Interface, INativeGuid 0x3A, 0x01, 0x02 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobEncoding.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobEncoding.cs index a2bdb2e..c1f9969 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobEncoding.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobEncoding.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcBlobEncoding : IDxcBlobEncoding.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xD4, 0x41, 0x72, 0x46, 0x26, 0x91, 0x41, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcBlobEncoding : IDxcBlobEncoding.Interface, INat 0x42, 0xFC, 0x68 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf16.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf16.cs index 97a86e5..b941480 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf16.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf16.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcBlobUtf16 : IDxcBlobUtf16.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAB, 0x4E, 0xF8, 0xA3, 0xAA, 0x0F, 0x7E, 0x49, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcBlobUtf16 : IDxcBlobUtf16.Interface, INativeGui 0x0B, 0x2D, 0x84 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf8.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf8.cs index 8275514..05d071e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf8.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcBlobUtf8.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcBlobUtf8 : IDxcBlobUtf8.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC9, 0x36, 0xA6, 0x3D, 0x71, 0xBA, 0x24, 0x40, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcBlobUtf8 : IDxcBlobUtf8.Interface, INativeGuid 0x25, 0x30, 0x5B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler.cs index 5e43d7c..d6b6403 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcCompiler : IDxcCompiler.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF3, 0x0B, 0x21, 0x8C, 0x1F, 0x01, 0x22, 0x44, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcCompiler : IDxcCompiler.Interface, INativeGuid 0x8D, 0xB6, 0x17 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler2.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler2.cs index 8f5df81..44be68b 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler2.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcCompiler2 : IDxcCompiler2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD9, 0xA9, 0x05, 0xA0, 0xBB, 0xB8, 0x94, 0x45, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcCompiler2 : IDxcCompiler2.Interface, INativeGui 0xEC, 0x4D, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler3.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler3.cs index 14bbf78..0cb7758 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompiler3.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcCompiler3 : IDxcCompiler3.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x87, 0x46, 0x8B, 0x22, 0x6A, 0x5A, 0x30, 0x47, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcCompiler3 : IDxcCompiler3.Interface, INativeGui 0x20, 0x3F, 0x54 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompilerArgs.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompilerArgs.cs index 9b2f46a..b22027c 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompilerArgs.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcCompilerArgs.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcCompilerArgs : IDxcCompilerArgs.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2A, 0xFE, 0xEF, 0x73, 0xDC, 0x70, 0xF8, 0x45, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcCompilerArgs : IDxcCompilerArgs.Interface, INat 0x02, 0x42, 0x9D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerBuilder.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerBuilder.cs index 129f117..31062e6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerBuilder.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerBuilder.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcContainerBuilder : IDxcContainerBuilder.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x50, 0x1F, 0x4B, 0x33, 0x92, 0x22, 0x35, 0x4B, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcContainerBuilder : IDxcContainerBuilder.Interfa 0x8C, 0x17, 0xFE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerReflection.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerReflection.cs index 156096d..7a972bc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcContainerReflection.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcContainerReflection : IDxcContainerReflection.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x26, 0x1B, 0xC2, 0xD2, 0x50, 0x83, 0xDC, 0x4B, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcContainerReflection : IDxcContainerReflection.I 0xF4, 0xC5, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcExtraOutputs.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcExtraOutputs.cs index f3d5e06..58fe9bb 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcExtraOutputs.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcExtraOutputs.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcExtraOutputs : IDxcExtraOutputs.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0x37, 0x9B, 0x31, 0xC2, 0xA5, 0x4A, 0x49, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcExtraOutputs : IDxcExtraOutputs.Interface, INat 0xFA, 0xF9, 0x89 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcIncludeHandler.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcIncludeHandler.cs index cfe97ba..c183a21 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcIncludeHandler.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcIncludeHandler.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcIncludeHandler : IDxcIncludeHandler.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7D, 0xFC, 0x61, 0x7F, 0x0D, 0x95, 0x7F, 0x46, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcIncludeHandler : IDxcIncludeHandler.Interface, 0x49, 0x18, 0x7C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLibrary.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLibrary.cs index 5dd2d44..d9ecfe5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLibrary.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLibrary.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcLibrary : IDxcLibrary.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC7, 0x4D, 0x20, 0xE5, 0x8C, 0xD1, 0x3C, 0x4C, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcLibrary : IDxcLibrary.Interface, INativeGuid 0x98, 0x0F, 0xE7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -134,7 +134,7 @@ public unsafe partial struct IDxcLibrary : IDxcLibrary.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(12)] - public HResult GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding) + public HResult GetBlobAsWide(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding) { return ((delegate* unmanaged[MemberFunction])(lpVtbl[12]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); } @@ -169,7 +169,7 @@ public unsafe partial struct IDxcLibrary : IDxcLibrary.Interface, INativeGuid HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding); [VtblIndex(12)] - HResult GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding); + HResult GetBlobAsWide(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding); } } diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLinker.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLinker.cs index 47cdeb4..08945bb 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLinker.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcLinker.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcLinker : IDxcLinker.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2A, 0xBE, 0xB5, 0xF1, 0xDD, 0x62, 0x27, 0x43, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcLinker : IDxcLinker.Interface, INativeGuid 0x1E, 0x78, 0xE6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOperationResult.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOperationResult.cs index 896a532..7864964 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOperationResult.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOperationResult.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcOperationResult : IDxcOperationResult.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4A, 0x48, 0xDB, 0xCE, 0xE9, 0xD4, 0x5A, 0x44, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcOperationResult : IDxcOperationResult.Interface 0x15, 0x7D, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizer.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizer.cs index 558c03d..4c915de 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizer.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizer.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcOptimizer : IDxcOptimizer.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2E, 0x0E, 0x74, 0x25, 0xBA, 0x9C, 0x1B, 0x40, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcOptimizer : IDxcOptimizer.Interface, INativeGui 0x39, 0xF2, 0x70 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizerPass.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizerPass.cs index 907cb49..c54f409 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizerPass.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcOptimizerPass.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcOptimizerPass : IDxcOptimizerPass.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0xD7, 0x2C, 0xAE, 0x22, 0xCC, 0x3F, 0x45, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcOptimizerPass : IDxcOptimizerPass.Interface, IN 0xA5, 0x20, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils.cs index ad12ea0..63ddc40 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcPdbUtils : IDxcPdbUtils.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7E, 0x64, 0xC9, 0xE6, 0x6A, 0x9D, 0x3B, 0x4C, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcPdbUtils : IDxcPdbUtils.Interface, INativeGuid 0x6C, 0x34, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils2.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils2.cs new file mode 100644 index 0000000..19c8ad0 --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcPdbUtils2.cs @@ -0,0 +1,325 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D.Dxc; + +/// IDxcPdbUtils2 +[Guid("4315d938-f369-4f93-95a2-252017cc3807")] +[NativeTypeName("struct IDxcPdbUtils2 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcPdbUtils2 : IDxcPdbUtils2.Interface, INativeGuid +{ + public static ref readonly Guid IID_IDxcPdbUtils2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x38, 0xD9, 0x15, 0x43, + 0x69, 0xF3, + 0x93, 0x4F, + 0x95, + 0xA2, + 0x25, + 0x20, + 0x17, + 0xCC, + 0x38, + 0x07 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcPdbUtils2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Load(IDxcBlob* pPdbOrDxil) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pPdbOrDxil); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetSourceCount(uint* pCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSource(uint uIndex, IDxcBlobEncoding** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetSourceName(uint uIndex, IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetLibraryPDBCount(uint* pCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[7]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetLibraryPDB(uint uIndex, IDxcPdbUtils2** ppOutPdbUtils, IDxcBlobUtf16** ppLibraryName) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[8]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppOutPdbUtils, ppLibraryName); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFlagCount(uint* pCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[9]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFlag(uint uIndex, IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[10]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetArgCount(uint* pCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[11]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetArg(uint uIndex, IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[12]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetArgPairCount(uint* pCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[13]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetArgPair(uint uIndex, IDxcBlobUtf16** ppName, IDxcBlobUtf16** ppValue) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[14]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppName, ppValue); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetDefineCount(uint* pCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[15]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetDefine(uint uIndex, IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[16]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetTargetProfile(IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[17]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetEntryPoint(IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[18]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetMainFileName(IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[19]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetHash(IDxcBlob** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[20]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetName(IDxcBlobUtf16** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[21]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetVersionInfo(IDxcVersionInfo** ppVersionInfo) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[22]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppVersionInfo); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetCustomToolchainID(uint* pID) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[23]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pID); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetCustomToolchainData(IDxcBlob** ppBlob) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[24]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppBlob); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetWholeDxil(IDxcBlob** ppResult) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[25]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public Bool32 IsFullPDB() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[26]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public Bool32 IsPDBRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[27]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this)); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + HResult Load(IDxcBlob* pPdbOrDxil); + + [VtblIndex(4)] + HResult GetSourceCount(uint* pCount); + + [VtblIndex(5)] + HResult GetSource(uint uIndex, IDxcBlobEncoding** ppResult); + + [VtblIndex(6)] + HResult GetSourceName(uint uIndex, IDxcBlobUtf16** ppResult); + + [VtblIndex(7)] + HResult GetLibraryPDBCount(uint* pCount); + + [VtblIndex(8)] + HResult GetLibraryPDB(uint uIndex, IDxcPdbUtils2** ppOutPdbUtils, IDxcBlobUtf16** ppLibraryName); + + [VtblIndex(9)] + HResult GetFlagCount(uint* pCount); + + [VtblIndex(10)] + HResult GetFlag(uint uIndex, IDxcBlobUtf16** ppResult); + + [VtblIndex(11)] + HResult GetArgCount(uint* pCount); + + [VtblIndex(12)] + HResult GetArg(uint uIndex, IDxcBlobUtf16** ppResult); + + [VtblIndex(13)] + HResult GetArgPairCount(uint* pCount); + + [VtblIndex(14)] + HResult GetArgPair(uint uIndex, IDxcBlobUtf16** ppName, IDxcBlobUtf16** ppValue); + + [VtblIndex(15)] + HResult GetDefineCount(uint* pCount); + + [VtblIndex(16)] + HResult GetDefine(uint uIndex, IDxcBlobUtf16** ppResult); + + [VtblIndex(17)] + HResult GetTargetProfile(IDxcBlobUtf16** ppResult); + + [VtblIndex(18)] + HResult GetEntryPoint(IDxcBlobUtf16** ppResult); + + [VtblIndex(19)] + HResult GetMainFileName(IDxcBlobUtf16** ppResult); + + [VtblIndex(20)] + HResult GetHash(IDxcBlob** ppResult); + + [VtblIndex(21)] + HResult GetName(IDxcBlobUtf16** ppResult); + + [VtblIndex(22)] + HResult GetVersionInfo(IDxcVersionInfo** ppVersionInfo); + + [VtblIndex(23)] + HResult GetCustomToolchainID(uint* pID); + + [VtblIndex(24)] + HResult GetCustomToolchainData(IDxcBlob** ppBlob); + + [VtblIndex(25)] + HResult GetWholeDxil(IDxcBlob** ppResult); + + [VtblIndex(26)] + Bool32 IsFullPDB(); + + [VtblIndex(27)] + Bool32 IsPDBRef(); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcResult.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcResult.cs index d178d7e..44439cf 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcResult.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcResult.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcResult : IDxcResult.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x6C, 0x34, 0x58, 0xE7, 0xDD, 0x97, 0x44, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcResult : IDxcResult.Interface, INativeGuid 0x5E, 0x06, 0x59 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcUtils.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcUtils.cs index 7f8e121..a55148f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcUtils.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcUtils.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcUtils : IDxcUtils.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCB, 0xC4, 0x05, 0x46, 0x19, 0x20, 0x2A, 0x49, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcUtils : IDxcUtils.Interface, INativeGuid 0xB7, 0xD6, 0x7F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -78,30 +78,30 @@ public unsafe partial struct IDxcUtils : IDxcUtils.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(4)] - public HResult CreateBlobFromPinned(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + public HResult CreateBlobFromPinned(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** ppBlobEncoding) { - return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, size, codePage, pBlobEncoding); + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, size, codePage, ppBlobEncoding); } [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public HResult MoveToBlob(void* pData, Com.IMalloc* pIMalloc, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + public HResult MoveToBlob(void* pData, Com.IMalloc* pIMalloc, uint size, DxcCp codePage, IDxcBlobEncoding** ppBlobEncoding) { - return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, pIMalloc, size, codePage, pBlobEncoding); + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, pIMalloc, size, codePage, ppBlobEncoding); } [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(6)] - public HResult CreateBlob(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + public HResult CreateBlob(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** ppBlobEncoding) { - return ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, size, codePage, pBlobEncoding); + return ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, size, codePage, ppBlobEncoding); } [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult LoadFile(char* pFileName, DxcCp* pCodePage, IDxcBlobEncoding** pBlobEncoding) + public HResult LoadFile(char* pFileName, DxcCp* pCodePage, IDxcBlobEncoding** ppBlobEncoding) { - return ((delegate* unmanaged[MemberFunction])(lpVtbl[7]))((IDxcUtils*)Unsafe.AsPointer(ref this), pFileName, pCodePage, pBlobEncoding); + return ((delegate* unmanaged[MemberFunction])(lpVtbl[7]))((IDxcUtils*)Unsafe.AsPointer(ref this), pFileName, pCodePage, ppBlobEncoding); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -120,16 +120,16 @@ public unsafe partial struct IDxcUtils : IDxcUtils.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobUtf8** pBlobEncoding) + public HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobUtf8** ppBlobEncoding) { - return ((delegate* unmanaged[MemberFunction])(lpVtbl[10]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); + return ((delegate* unmanaged[MemberFunction])(lpVtbl[10]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, ppBlobEncoding); } [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(11)] - public HResult GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobUtf16** pBlobEncoding) + public HResult GetBlobAsWide(IDxcBlob* pBlob, IDxcBlobUtf16** ppBlobEncoding) { - return ((delegate* unmanaged[MemberFunction])(lpVtbl[11]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); + return ((delegate* unmanaged[MemberFunction])(lpVtbl[11]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, ppBlobEncoding); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -166,16 +166,16 @@ public unsafe partial struct IDxcUtils : IDxcUtils.Interface, INativeGuid HResult CreateBlobFromBlob(IDxcBlob* pBlob, uint offset, uint length, IDxcBlob** ppResult); [VtblIndex(4)] - HResult CreateBlobFromPinned(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding); + HResult CreateBlobFromPinned(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** ppBlobEncoding); [VtblIndex(5)] - HResult MoveToBlob(void* pData, Com.IMalloc* pIMalloc, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding); + HResult MoveToBlob(void* pData, Com.IMalloc* pIMalloc, uint size, DxcCp codePage, IDxcBlobEncoding** ppBlobEncoding); [VtblIndex(6)] - HResult CreateBlob(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding); + HResult CreateBlob(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** ppBlobEncoding); [VtblIndex(7)] - HResult LoadFile(char* pFileName, DxcCp* pCodePage, IDxcBlobEncoding** pBlobEncoding); + HResult LoadFile(char* pFileName, DxcCp* pCodePage, IDxcBlobEncoding** ppBlobEncoding); [VtblIndex(8)] HResult CreateReadOnlyStreamFromBlob(IDxcBlob* pBlob, Com.IStream** ppStream); @@ -184,10 +184,10 @@ public unsafe partial struct IDxcUtils : IDxcUtils.Interface, INativeGuid HResult CreateDefaultIncludeHandler(IDxcIncludeHandler** ppResult); [VtblIndex(10)] - HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobUtf8** pBlobEncoding); + HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobUtf8** ppBlobEncoding); [VtblIndex(11)] - HResult GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobUtf16** pBlobEncoding); + HResult GetBlobAsWide(IDxcBlob* pBlob, IDxcBlobUtf16** ppBlobEncoding); [VtblIndex(12)] HResult GetDxilContainerPart(DxcBuffer* pShader, uint DxcPart, void** ppPartData, uint* pPartSizeInBytes); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator.cs index 1138a92..46bfeaa 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcValidator : IDxcValidator.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD2, 0x2B, 0xE8, 0xA6, 0xD7, 0x1F, 0x26, 0x48, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcValidator : IDxcValidator.Interface, INativeGui 0x97, 0xF4, 0x9A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator2.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator2.cs index ddd5985..7938f4f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcValidator2.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcValidator2 : IDxcValidator2.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD1, 0x1F, 0x8E, 0x45, 0xB2, 0xB1, 0x50, 0x47, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcValidator2 : IDxcValidator2.Interface, INativeG 0x3B, 0xED, 0x92 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo.cs index 05493b9..76c8482 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcVersionInfo : IDxcVersionInfo.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x50, 0x5B, 0x4F, 0xB0, 0x59, 0x20, 0x12, 0x4F, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcVersionInfo : IDxcVersionInfo.Interface, INativ 0xE1, 0xCC, 0x7E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo2.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo2.cs index 3a75891..0cae224 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo2.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcVersionInfo2 : IDxcVersionInfo2.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0x04, 0x69, 0xFB, 0xF0, 0x42, 0x62, 0x4B, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcVersionInfo2 : IDxcVersionInfo2.Interface, INat 0xDA, 0x7C, 0x83 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo3.cs b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo3.cs index e9e542b..c18fcf2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D.Dxc/Generated/IDxcVersionInfo3.cs @@ -20,7 +20,7 @@ public unsafe partial struct IDxcVersionInfo3 : IDxcVersionInfo3.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x43, 0xE8, 0x13, 0x5E, 0x25, 0x9D, 0x3C, 0x47, @@ -32,7 +32,7 @@ public unsafe partial struct IDxcVersionInfo3 : IDxcVersionInfo3.Interface, INat 0xB4, 0x4B, 0x1E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Apis.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Apis.cs index b8a3b50..c5d3532 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Apis.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Apis.cs @@ -780,7 +780,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4B, 0xF4, 0xA9, 0xE6, 0xB0, 0x61, 0x63, 0x45, @@ -792,7 +792,7 @@ public static partial class Apis 0xC6, 0xFE, 0x66 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -804,7 +804,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x00, 0xAD, 0x22, 0xBF, 0xEA, 0x03, 0x90, 0x46, @@ -816,7 +816,7 @@ public static partial class Apis 0x20, 0x9B, 0x7E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -828,7 +828,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7F, 0x41, 0x27, 0xEE, 0x28, 0x5E, 0x65, 0x4E, @@ -840,7 +840,7 @@ public static partial class Apis 0x08, 0xAD, 0xC9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -852,7 +852,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0xC7, 0x3E, 0x6F, 0x35, 0x37, 0xCC, 0x42, @@ -864,7 +864,7 @@ public static partial class Apis 0xB3, 0x66, 0x16 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -876,7 +876,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x12, 0x5F, 0x69, 0x86, 0x0E, 0x34, 0x04, 0x4F, @@ -888,7 +888,7 @@ public static partial class Apis 0x32, 0x74, 0x60 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -900,7 +900,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x64, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -912,7 +912,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -924,7 +924,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x65, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -936,7 +936,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -948,7 +948,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -960,7 +960,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -972,7 +972,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x67, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -984,7 +984,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -996,7 +996,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x68, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1008,7 +1008,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1020,7 +1020,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x69, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1032,7 +1032,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1044,7 +1044,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF9, 0x4F, 0xF0, 0xD5, 0x18, 0x34, 0xD8, 0x45, @@ -1056,7 +1056,7 @@ public static partial class Apis 0xAE, 0x2D, 0xDD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1068,7 +1068,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0xE8, 0x9B, 0xD7, 0xF1, 0x0C, 0x81, 0x4C, @@ -1080,7 +1080,7 @@ public static partial class Apis 0x36, 0xF4, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1092,7 +1092,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBB, 0xCC, 0xAA, 0xF9, 0xB6, 0xC2, 0xFC, 0x4C, @@ -1104,7 +1104,7 @@ public static partial class Apis 0x76, 0x05, 0x52 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1116,7 +1116,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x82, 0x9D, 0x5B, 0x70, 0xCF, 0x76, 0xD6, 0x49, @@ -1128,7 +1128,7 @@ public static partial class Apis 0xDB, 0x01, 0x3C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1140,7 +1140,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x80, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1152,7 +1152,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1164,7 +1164,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x81, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1176,7 +1176,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1188,7 +1188,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x90, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1200,7 +1200,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1212,7 +1212,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x91, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1224,7 +1224,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1236,7 +1236,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x94, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1248,7 +1248,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1260,7 +1260,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA0, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1272,7 +1272,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1284,7 +1284,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA1, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1296,7 +1296,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1308,7 +1308,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1320,7 +1320,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1332,7 +1332,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA3, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1344,7 +1344,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1356,7 +1356,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0xBE, 0x81, 0x1B, 0xC7, 0xA0, 0xD3, 0x11, @@ -1368,7 +1368,7 @@ public static partial class Apis 0x2E, 0x73, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1380,7 +1380,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x74, 0x4D, 0xD6, 0xEF, 0xE8, 0xC9, 0xD7, 0x41, @@ -1392,7 +1392,7 @@ public static partial class Apis 0x9F, 0xA3, 0x19 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1404,7 +1404,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0x8A, 0x41, 0xED, 0x0D, 0x01, 0xDA, 0x4E, @@ -1416,7 +1416,7 @@ public static partial class Apis 0x8D, 0x8D, 0x2E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1428,7 +1428,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0x8B, 0x99, 0xAB, 0x58, 0x42, 0xA9, 0x44, @@ -1440,7 +1440,7 @@ public static partial class Apis 0xA6, 0xBA, 0xAE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1452,7 +1452,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1B, 0xD5, 0x11, 0x5B, 0x4C, 0x2F, 0x52, 0x44, @@ -1464,7 +1464,7 @@ public static partial class Apis 0x16, 0x0C, 0xC0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1476,7 +1476,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE0, 0xF0, 0x7A, 0x10, 0x1A, 0xEF, 0x19, 0x4D, @@ -1488,7 +1488,247 @@ public static partial class Apis 0x07, 0x3D, 0x13 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MONOCHROME + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x93, 0xB9, 0x85, 0x06, + 0x8C, 0x3D, + 0xA0, 0x43, + 0x8B, + 0x28, + 0xD7, + 0x4C, + 0x2D, + 0x68, + 0x99, + 0xA4 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MONOCHROME10 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x0F, 0x1D, 0x2A, 0x14, + 0xDD, 0x69, + 0xC9, 0x4E, + 0x85, + 0x91, + 0xB1, + 0x2F, + 0xFC, + 0xB9, + 0x1A, + 0x29 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN12 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x5F, 0x92, 0x72, 0x1A, + 0x2C, 0x0C, + 0x15, 0x4F, + 0x96, + 0xFB, + 0xB1, + 0x7D, + 0x14, + 0x73, + 0x60, + 0x3F + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10_422 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xE5, 0x4F, 0xAC, 0x0B, + 0x32, 0x15, + 0x29, 0x44, + 0xA8, + 0x54, + 0xF8, + 0x4D, + 0xE0, + 0x49, + 0x53, + 0xDB + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN12_422 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x81, 0xAC, 0xBC, 0x55, + 0x11, 0xF3, + 0x93, 0x40, + 0xA7, + 0xD0, + 0x1C, + 0xBC, + 0x0B, + 0x84, + 0x9B, + 0xEE + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN_444 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x8F, 0x01, 0x08, 0x40, + 0x37, 0xF5, + 0x36, 0x4B, + 0x98, + 0xCF, + 0x61, + 0xAF, + 0x8A, + 0x2C, + 0x1A, + 0x33 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10_EXT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x90, 0x54, 0xC5, 0x9C, + 0x7C, 0xE3, + 0x32, 0x49, + 0x86, + 0x84, + 0x49, + 0x20, + 0xF9, + 0xF6, + 0x40, + 0x9C + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10_444 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xFA, 0xEF, 0xAB, 0x0D, + 0x58, 0x44, + 0x02, 0x46, + 0xBC, + 0x03, + 0x07, + 0x95, + 0x65, + 0x9D, + 0x61, + 0x7C + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN12_444 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x4D, 0x63, 0x98, 0x97, + 0x9D, 0xFE, + 0xE5, 0x48, + 0xB4, + 0xDA, + 0xDB, + 0xEC, + 0x45, + 0xB3, + 0xDF, + 0x01 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN16 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xB0, 0xDB, 0xFB, 0xA4, + 0x13, 0xA1, + 0x2B, 0x48, + 0xA2, + 0x32, + 0x63, + 0x5C, + 0xC0, + 0x69, + 0x7F, + 0x6D + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1500,7 +1740,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF8, 0x07, 0x37, 0x46, 0xD0, 0xA1, 0x85, 0x45, @@ -1512,7 +1752,7 @@ public static partial class Apis 0x60, 0xB8, 0x9E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1524,7 +1764,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEF, 0x49, 0xC7, 0xA4, 0xCF, 0x6E, 0xAA, 0x48, @@ -1536,7 +1776,7 @@ public static partial class Apis 0x16, 0x5F, 0xF7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1548,7 +1788,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEA, 0x99, 0xB8, 0x90, 0x62, 0x3A, 0x05, 0x47, @@ -1560,7 +1800,7 @@ public static partial class Apis 0x27, 0x44, 0xE7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1572,7 +1812,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCB, 0x4C, 0xBE, 0xB8, 0x53, 0xCF, 0xBA, 0x46, @@ -1584,7 +1824,7 @@ public static partial class Apis 0xDA, 0x5D, 0x2A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1596,7 +1836,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0F, 0xFF, 0x36, 0x69, 0xB1, 0x45, 0x63, 0x41, @@ -1608,7 +1848,7 @@ public static partial class Apis 0x94, 0x61, 0x08 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1620,7 +1860,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA1, 0x2A, 0x5F, 0x0C, 0x41, 0xE5, 0x89, 0x40, @@ -1632,7 +1872,7 @@ public static partial class Apis 0x19, 0xD7, 0xC8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1644,7 +1884,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x09, 0x70, 0x12, 0x17, 0x0F, 0xA0, 0xE1, 0x4C, @@ -1656,7 +1896,7 @@ public static partial class Apis 0xF6, 0xF3, 0xF0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1668,7 +1908,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0xBE, 0x80, 0x2D, 0xAC, 0x9C, 0x35, 0x48, @@ -1680,7 +1920,175 @@ public static partial class Apis 0x4F, 0x9E, 0xE8 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MJPEG_VLD_420 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x06, 0xB5, 0x5C, 0x72, + 0x29, 0x0C, + 0xC4, 0x43, + 0x94, + 0x40, + 0x8E, + 0x93, + 0x97, + 0x90, + 0x3A, + 0x04 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MJPEG_VLD_422 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xCD, 0xB9, 0x77, 0x5B, + 0x35, 0x1A, + 0x30, 0x4C, + 0x9F, + 0xD8, + 0xEF, + 0x4B, + 0x60, + 0xC0, + 0x35, + 0xDD + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MJPEG_VLD_444 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xF9, 0x61, 0x51, 0xD9, + 0x44, 0x0D, + 0xE6, 0x47, + 0xBC, + 0xF5, + 0x1B, + 0xFB, + 0xFB, + 0x26, + 0x8F, + 0x97 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MJPEG_VLD_4444 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xD5, 0x48, 0x17, 0xC9, + 0x18, 0xFD, + 0xCA, 0x4A, + 0x9D, + 0xB3, + 0x3A, + 0x66, + 0x34, + 0xAB, + 0x54, + 0x7D + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_JPEG_VLD_420 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x83, 0x2C, 0x78, 0xCF, + 0xF5, 0xBE, + 0x2C, 0x4A, + 0x87, + 0xCB, + 0x60, + 0x19, + 0xE7, + 0xB1, + 0x75, + 0xAC + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_JPEG_VLD_422 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x17, 0xF4, 0x4D, 0xF0, + 0xE2, 0xEE, + 0x67, 0x40, + 0xA7, + 0x78, + 0xF3, + 0x5C, + 0x15, + 0xAB, + 0x97, + 0x21 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_JPEG_VLD_444 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x17, 0x0E, 0xD0, 0x4C, + 0xBA, 0x89, + 0xEF, 0x48, + 0xB9, + 0xF9, + 0xED, + 0xCB, + 0x82, + 0x71, + 0x3F, + 0x65 + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1692,7 +2100,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x11, 0xD7, 0x6B, 0x9B, 0x74, 0x4F, 0xC9, 0x41, @@ -1704,7 +2112,7 @@ public static partial class Apis 0xD9, 0x3B, 0x4F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1716,7 +2124,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4F, 0xAC, 0xD6, 0x89, 0xF2, 0x09, 0x29, 0x42, @@ -1728,7 +2136,7 @@ public static partial class Apis 0x6D, 0xFD, 0x81 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1740,7 +2148,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x35, 0x52, 0x40, 0xB0, 0x3D, 0xC1, 0xF2, 0x44, @@ -1752,7 +2160,7 @@ public static partial class Apis 0x8E, 0x5B, 0x67 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1764,7 +2172,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0x93, 0x2D, 0x42, 0x21, 0x9D, 0xB7, 0x4B, @@ -1776,7 +2184,7 @@ public static partial class Apis 0x2C, 0x3E, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1788,7 +2196,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0x0D, 0x17, 0xB1, 0x8D, 0x62, 0xA3, 0x4D, @@ -1800,7 +2208,7 @@ public static partial class Apis 0x8B, 0x49, 0x70 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1812,7 +2220,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x84, 0xB5, 0x4E, 0xA8, 0x95, 0xC4, 0xAA, 0x48, @@ -1824,7 +2232,7 @@ public static partial class Apis 0xFB, 0xCE, 0x05 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1836,7 +2244,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA5, 0x18, 0x1B, 0xBC, 0xFB, 0xB1, 0xAB, 0x42, @@ -1848,7 +2256,7 @@ public static partial class Apis 0x4B, 0xF7, 0xBE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1860,7 +2268,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9D, 0x53, 0x1C, 0xEC, 0xFF, 0x8C, 0x2A, 0x4E, @@ -1872,7 +2280,7 @@ public static partial class Apis 0x99, 0xF4, 0x80 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1884,7 +2292,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9E, 0x49, 0x34, 0x26, 0x18, 0xD0, 0x74, 0x4D, @@ -1896,7 +2304,7 @@ public static partial class Apis 0x59, 0x52, 0x8D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1908,7 +2316,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB3, 0x07, 0xB2, 0x0D, 0x50, 0x94, 0xA6, 0x46, @@ -1920,7 +2328,7 @@ public static partial class Apis 0x4F, 0x9C, 0xF2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1932,7 +2340,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0xBA, 0x9B, 0x64, 0xF4, 0xF0, 0x39, 0x46, @@ -1944,7 +2352,7 @@ public static partial class Apis 0xC3, 0xAB, 0xAC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1956,7 +2364,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0x0B, 0x2F, 0x01, 0x62, 0xE6, 0x74, 0x44, @@ -1968,7 +2376,7 @@ public static partial class Apis 0x14, 0x3C, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1980,7 +2388,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5E, 0x2B, 0x04, 0x2C, 0x07, 0x8C, 0xD5, 0x46, @@ -1992,7 +2400,7 @@ public static partial class Apis 0xAD, 0x4C, 0x31 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2004,7 +2412,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA3, 0xDC, 0x9D, 0x83, 0x4E, 0x9B, 0xE4, 0x41, @@ -2016,7 +2424,7 @@ public static partial class Apis 0xA1, 0x1E, 0xE7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2028,7 +2436,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD2, 0xD9, 0x14, 0x62, 0x2C, 0x43, 0xBB, 0x4A, @@ -2040,7 +2448,7 @@ public static partial class Apis 0x26, 0x9E, 0x3B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2052,7 +2460,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0x70, 0x0F, 0xB3, 0x3C, 0x20, 0x07, 0x4B, @@ -2064,7 +2472,7 @@ public static partial class Apis 0x61, 0x24, 0x1E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2076,7 +2484,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x58, 0x59, 0x3A, 0xF8, 0x86, 0xE9, 0xDA, 0x4B, @@ -2088,7 +2496,7 @@ public static partial class Apis 0x7A, 0x01, 0xB7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2100,7 +2508,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC7, 0x91, 0x17, 0xEC, 0xD3, 0xDA, 0x15, 0x4F, @@ -2112,7 +2520,7 @@ public static partial class Apis 0x60, 0xD4, 0xF0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2124,7 +2532,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0x4B, 0x11, 0x06, 0x23, 0x35, 0x0A, 0x47, @@ -2136,7 +2544,7 @@ public static partial class Apis 0x51, 0x54, 0xF0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2148,7 +2556,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x58, 0x56, 0x45, 0x50, 0x47, 0x3F, 0x62, 0x43, @@ -2160,7 +2568,7 @@ public static partial class Apis 0xE9, 0xED, 0x29 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2172,7 +2580,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x54, 0xCC, 0x46, 0x63, 0xFC, 0x2C, 0xD4, 0x4A, @@ -2184,7 +2592,7 @@ public static partial class Apis 0xDE, 0x77, 0x00 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2196,7 +2604,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x47, 0xD0, 0x72, 0x07, 0x40, 0x1B, 0xE8, 0x48, @@ -2208,7 +2616,7 @@ public static partial class Apis 0xDE, 0x9F, 0x01 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2220,7 +2628,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x86, 0xF2, 0xFF, 0x41, 0xE0, 0x6A, 0x43, 0x4D, @@ -2232,7 +2640,7 @@ public static partial class Apis 0xFD, 0x15, 0x8A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2244,7 +2652,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x95, 0x98, 0x94, 0xC1, 0x2A, 0xD7, 0x1D, 0x4A, @@ -2256,7 +2664,7 @@ public static partial class Apis 0x17, 0x15, 0x20 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2288,7 +2696,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7B, 0x31, 0x99, 0x4B, 0x39, 0xAC, 0xA6, 0x4A, @@ -2300,7 +2708,7 @@ public static partial class Apis 0x84, 0x79, 0x8F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2467,6 +2875,7 @@ public static partial class Apis public const ResourceMiscFlags D3D11_RESOURCE_MISC_HW_PROTECTED = ResourceMiscFlags.HWProtected; public const ResourceMiscFlags D3D11_RESOURCE_MISC_SHARED_DISPLAYABLE = ResourceMiscFlags.SharedDisplayable; public const ResourceMiscFlags D3D11_RESOURCE_MISC_SHARED_EXCLUSIVE_WRITER = ResourceMiscFlags.SharedExclusiveWriter; + public const ResourceMiscFlags D3D11_RESOURCE_MISC_NO_SHADER_ACCESS = ResourceMiscFlags.NoShaderAccess; public const MapMode D3D11_MAP_READ = MapMode.Read; public const MapMode D3D11_MAP_WRITE = MapMode.Write; public const MapMode D3D11_MAP_READ_WRITE = MapMode.ReadWrite; @@ -2672,6 +3081,7 @@ public static partial class Apis public const Feature D3D11_FEATURE_SHADER_CACHE = Feature.ShaderCache; public const Feature D3D11_FEATURE_D3D11_OPTIONS5 = Feature.Options5; public const Feature D3D11_FEATURE_DISPLAYABLE = Feature.Displayable; + public const Feature D3D11_FEATURE_D3D11_OPTIONS6 = Feature.Options6; public const ShaderMinPrecisionSupport D3D11_SHADER_MIN_PRECISION_10_BIT = ShaderMinPrecisionSupport.P10Bit; public const ShaderMinPrecisionSupport D3D11_SHADER_MIN_PRECISION_16_BIT = ShaderMinPrecisionSupport.P16Bit; public const TiledResourcesTier D3D11_TILED_RESOURCES_NOT_SUPPORTED = TiledResourcesTier.NotSupported; @@ -2689,6 +3099,8 @@ public static partial class Apis public const SharedResourceTier D3D11_SHARED_RESOURCE_TIER_1 = SharedResourceTier.Tier1; public const SharedResourceTier D3D11_SHARED_RESOURCE_TIER_2 = SharedResourceTier.Tier2; public const SharedResourceTier D3D11_SHARED_RESOURCE_TIER_3 = SharedResourceTier.Tier3; + public const ShaderAccessRestrictedResourceTier D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER_0 = ShaderAccessRestrictedResourceTier.Tier0; + public const ShaderAccessRestrictedResourceTier D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER_1 = ShaderAccessRestrictedResourceTier.Tier1; public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS = VideoDecoderBufferType.PictureParameters; public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL = VideoDecoderBufferType.MacroblockControl; public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE = VideoDecoderBufferType.ResidualDifference; @@ -2698,6 +3110,7 @@ public static partial class Apis public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_BITSTREAM = VideoDecoderBufferType.Bitstream; public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR = VideoDecoderBufferType.MotionVector; public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN = VideoDecoderBufferType.FilmGrain; + public const VideoDecoderBufferType D3D11_VIDEO_DECODER_BUFFER_HUFFMAN_TABLE = VideoDecoderBufferType.HuffmanTable; public const VideoProcessorFormatSupport D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT = VideoProcessorFormatSupport.Input; public const VideoProcessorFormatSupport D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT = VideoProcessorFormatSupport.Output; public const VideoProcessorDeviceCaps D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_LINEAR_SPACE = VideoProcessorDeviceCaps.LinearSpace; @@ -4212,6 +4625,7 @@ public static partial class Apis public const MessageId D3D11_MESSAGE_ID_NO_TRACKED_WORKLOAD_SLOT_AVAILABLE = MessageId.NoTrackedWorkloadSlotAvailable; public const MessageId D3D11_MESSAGE_ID_END_TRACKED_WORKLOAD_INVALID_ARG = MessageId.EndTrackedWorkloadInvalidArg; public const MessageId D3D11_MESSAGE_ID_TRACKED_WORKLOAD_DISJOINT_FAILURE = MessageId.TrackedWorkloadDisjointFailure; + public const MessageId D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_AND_WRITE_MASK_MISMATCH = MessageId.DeviceDrawResourceFormatAndWriteMaskMismatch; public const CopyFlags D3D11_COPY_NO_OVERWRITE = CopyFlags.NoOverwrite; public const CopyFlags D3D11_COPY_DISCARD = CopyFlags.Discard; public const LogicOperation D3D11_LOGIC_OP_CLEAR = LogicOperation.Clear; diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Enums.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Enums.cs index cf8e45f..615f5b5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Enums.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Enums.cs @@ -289,6 +289,9 @@ public enum ResourceMiscFlags /// /// D3D11_RESOURCE_MISC_SHARED_EXCLUSIVE_WRITER SharedExclusiveWriter = 2097152, + /// + /// D3D11_RESOURCE_MISC_NO_SHADER_ACCESS + NoShaderAccess = 4194304, } /// @@ -1094,6 +1097,9 @@ public enum Feature /// /// D3D11_FEATURE_DISPLAYABLE Displayable = 20, + /// + /// D3D11_FEATURE_D3D11_OPTIONS6 + Options6 = 21, } /// @@ -1178,6 +1184,18 @@ public enum SharedResourceTier Tier3 = 3, } +/// +/// D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER +public enum ShaderAccessRestrictedResourceTier +{ + /// + /// D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER_0 + Tier0 = 0, + /// + /// D3D11_SHADER_ACCESS_RESTRICTED_RESOURCE_TIER_1 + Tier1 = 1, +} + /// /// D3D11_VIDEO_DECODER_BUFFER_TYPE public enum VideoDecoderBufferType @@ -1209,6 +1227,9 @@ public enum VideoDecoderBufferType /// /// D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN FilmGrain = 8, + /// + /// D3D11_VIDEO_DECODER_BUFFER_HUFFMAN_TABLE + HuffmanTable = 9, } /// @@ -5947,6 +5968,9 @@ public enum MessageId /// /// D3D11_MESSAGE_ID_TRACKED_WORKLOAD_DISJOINT_FAILURE TrackedWorkloadDisjointFailure = 3146283, + /// + /// D3D11_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_AND_WRITE_MASK_MISMATCH + DeviceDrawResourceFormatAndWriteMaskMismatch = 3146284, } /// diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Structs.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Structs.cs index 2af342f..9e68105 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Structs.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/Graphics.Direct3D11.Structs.cs @@ -1851,6 +1851,14 @@ public partial struct FeatureDataD3D11Options5 public SharedResourceTier SharedResourceTier; } +/// +/// D3D11_FEATURE_DATA_D3D11_OPTIONS6 +public partial struct FeatureDataD3D11Options6 +{ + /// + public ShaderAccessRestrictedResourceTier ShaderAccessRestrictedResourceTier; +} + /// /// D3D11_VIDEO_DECODER_DESC public partial struct VideoDecoderDescription diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Asynchronous.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Asynchronous.cs index 3b6e54d..daf0483 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Asynchronous.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Asynchronous.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Asynchronous : ID3D11Asynchronous.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCD, 0xD0, 0x35, 0x4B, 0x15, 0x1E, 0x58, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Asynchronous : ID3D11Asynchronous.Interface, 0xF6, 0xDD, 0x3B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11AuthenticatedChannel.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11AuthenticatedChannel.cs index 5920141..fbd8e3c 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11AuthenticatedChannel.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11AuthenticatedChannel.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11AuthenticatedChannel : ID3D11AuthenticatedCha [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x08, 0xA3, 0x15, 0x30, 0xBD, 0xDC, 0xAA, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11AuthenticatedChannel : ID3D11AuthenticatedCha 0xD1, 0x4D, 0x4A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState.cs index 88b5d9c..c6f7824 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11BlendState : ID3D11BlendState.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0x8F, 0xB6, 0x75, 0x7D, 0x34, 0x59, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11BlendState : ID3D11BlendState.Interface, INat 0x01, 0xCD, 0x9A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState1.cs index 7b372b7..1571f3a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11BlendState1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11BlendState1 : ID3D11BlendState1.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBE, 0xFA, 0x86, 0xCC, 0x55, 0xDA, 0x1D, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11BlendState1 : ID3D11BlendState1.Interface, IN 0x28, 0x77, 0xE9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Buffer.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Buffer.cs index a4e48ae..70d7d21 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Buffer.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Buffer.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Buffer : ID3D11Buffer.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0x0B, 0x57, 0x48, 0xEE, 0xD1, 0xCD, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Buffer : ID3D11Buffer.Interface, INativeGuid 0x22, 0xB0, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassInstance.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassInstance.cs index 57b6174..769128b 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassInstance.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassInstance.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ClassInstance : ID3D11ClassInstance.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0x7F, 0xCD, 0xA6, 0xB7, 0xB0, 0x2F, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ClassInstance : ID3D11ClassInstance.Interface 0x57, 0x97, 0xCB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassLinkage.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassLinkage.cs index 01beb8a..6f7c442 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassLinkage.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ClassLinkage.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ClassLinkage : ID3D11ClassLinkage.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBA, 0x7C, 0xF5, 0xDD, 0x43, 0x95, 0xE4, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ClassLinkage : ID3D11ClassLinkage.Interface, 0xFE, 0x7F, 0xED - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CommandList.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CommandList.cs index 801ba6e..736c4c0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CommandList.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CommandList.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11CommandList : ID3D11CommandList.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD1, 0xC4, 0x4B, 0xA2, 0x9E, 0x76, 0xF7, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11CommandList : ID3D11CommandList.Interface, IN 0x6C, 0x18, 0xE2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ComputeShader.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ComputeShader.cs index be4cbe8..1cf3c93 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ComputeShader.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ComputeShader.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ComputeShader : ID3D11ComputeShader.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0x19, 0x5B, 0x4F, 0xBD, 0xC2, 0x5E, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ComputeShader : ID3D11ComputeShader.Interface 0x8E, 0x49, 0x69 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Counter.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Counter.cs index 6f4cc56..9b0b808 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Counter.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Counter.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Counter : ID3D11Counter.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFB, 0x49, 0x8C, 0x6E, 0x71, 0xA3, 0x70, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Counter : ID3D11Counter.Interface, INativeGui 0x22, 0xB7, 0x41 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CryptoSession.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CryptoSession.cs index 8022082..3754f97 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CryptoSession.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11CryptoSession.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11CryptoSession : ID3D11CryptoSession.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAD, 0xF9, 0x32, 0x9B, 0xCC, 0xBD, 0xA6, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11CryptoSession : ID3D11CryptoSession.Interface 0x84, 0x57, 0x20 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Debug.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Debug.cs index 0436124..bc08005 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Debug.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Debug.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Debug : ID3D11Debug.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x33, 0x22, 0xCF, 0x79, 0x36, 0x75, 0x48, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Debug : ID3D11Debug.Interface, INativeGuid 0xDC, 0x57, 0x60 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilState.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilState.cs index d7a09ab..03e04b0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilState.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilState.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DepthStencilState : ID3D11DepthStencilState.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFB, 0x3E, 0x82, 0x03, 0x8F, 0x8D, 0x1C, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DepthStencilState : ID3D11DepthStencilState.I 0xCB, 0xFD, 0xF1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilView.cs index 55790be..b697531 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DepthStencilView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DepthStencilView : ID3D11DepthStencilView.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2A, 0xC9, 0xDA, 0x9F, 0x76, 0x18, 0xC3, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DepthStencilView : ID3D11DepthStencilView.Int 0x84, 0xA9, 0xB6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device.cs index 74188df..b5902d6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Device : ID3D11Device.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0x6D, 0x6F, 0xDB, 0x77, 0xAC, 0x88, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Device : ID3D11Device.Interface, INativeGuid 0xBB, 0xF1, 0x40 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device1.cs index 1b7288b..56041c2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Device1 : ID3D11Device1.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x29, 0xFB, 0x4B, 0xA0, 0xEF, 0x08, 0xD6, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Device1 : ID3D11Device1.Interface, INativeGui 0xCB, 0xE6, 0x86 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device2.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device2.cs index fc0c7e9..b7a831a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Device2 : ID3D11Device2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFA, 0xDF, 0x06, 0x9D, 0xE5, 0xD1, 0x07, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Device2 : ID3D11Device2.Interface, INativeGui 0xF2, 0xF8, 0x41 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device3.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device3.cs index f226f5a..3ea0aba 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Device3 : ID3D11Device3.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0x8C, 0x5C, 0xA0, 0xC6, 0xD2, 0x32, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Device3 : ID3D11Device3.Interface, INativeGui 0xDC, 0x9A, 0xE6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device4.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device4.cs index 58bcfac..c32d219 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device4.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Device4 : ID3D11Device4.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x71, 0xAB, 0x92, 0x89, 0xE6, 0x02, 0x8D, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Device4 : ID3D11Device4.Interface, INativeGui 0xDA, 0x42, 0xC4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device5.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device5.cs index 588b568..217228a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device5.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Device5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Device5 : ID3D11Device5.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0xE2, 0xFD, 0x8F, 0xE7, 0xA0, 0xDF, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Device5 : ID3D11Device5.Interface, INativeGui 0x1B, 0x5E, 0xA0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceChild.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceChild.cs index 34fcd5b..adebe39 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceChild.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceChild.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DeviceChild : ID3D11DeviceChild.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC8, 0xE5, 0x41, 0x18, 0xB0, 0x16, 0x9B, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DeviceChild : ID3D11DeviceChild.Interface, IN 0xD5, 0xDE, 0xAE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext.cs index ec322f2..72b76ff 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DeviceContext : ID3D11DeviceContext.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6C, 0xA9, 0xBF, 0xC0, 0x89, 0xE0, 0xFB, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DeviceContext : ID3D11DeviceContext.Interface 0x61, 0x90, 0xDA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext1.cs index 02576ab..02c7fbc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DeviceContext1 : ID3D11DeviceContext1.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0x6F, 0x2C, 0xBB, 0xFB, 0xB5, 0x82, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DeviceContext1 : ID3D11DeviceContext1.Interfa 0xFA, 0x90, 0xE1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext2.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext2.cs index 83dc07d..e327ad4 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DeviceContext2 : ID3D11DeviceContext2.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x32, 0x5B, 0x0D, 0x42, 0x0C, 0xB9, 0xA4, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DeviceContext2 : ID3D11DeviceContext2.Interfa 0x24, 0xA8, 0x3A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext3.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext3.cs index 33af7e4..7bb221c 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DeviceContext3 : ID3D11DeviceContext3.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1D, 0xC0, 0xE3, 0xB4, 0x9E, 0xE7, 0x37, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DeviceContext3 : ID3D11DeviceContext3.Interfa 0x4C, 0x9B, 0x8F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext4.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext4.cs index 44948cb..1323ffc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext4.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DeviceContext4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DeviceContext4 : ID3D11DeviceContext4.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x00, 0x76, 0x91, 0x8C, 0xF5, 0x33, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DeviceContext4 : ID3D11DeviceContext4.Interfa 0x90, 0xFA, 0x24 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DomainShader.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DomainShader.cs index c774064..576787c 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DomainShader.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11DomainShader.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11DomainShader : ID3D11DomainShader.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x08, 0xC5, 0x82, 0xF5, 0x36, 0x0F, 0x0C, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11DomainShader : ID3D11DomainShader.Interface, 0x26, 0x8C, 0xFA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Fence.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Fence.cs index 22e04c1..e54b1c3 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Fence.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Fence.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Fence : ID3D11Fence.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD1, 0xE9, 0xFD, 0xAF, 0xF7, 0x1D, 0xB7, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Fence : ID3D11Fence.Interface, INativeGuid 0x1D, 0xAB, 0x80 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionLinkingGraph.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionLinkingGraph.cs index fe13a31..2e21541 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionLinkingGraph.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionLinkingGraph.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11FunctionLinkingGraph : ID3D11FunctionLinkingG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x20, 0x32, 0x13, 0x54, 0xE8, 0x1C, 0xD3, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11FunctionLinkingGraph : ID3D11FunctionLinkingG 0xCE, 0xEC, 0xFF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionParameterReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionParameterReflection.cs index 53a1ce7..f2d0008 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionParameterReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionParameterReflection.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D11FunctionParameterReflection : ID3D11FunctionP [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x88, 0x74, 0x75, 0x42, 0x4F, 0x33, 0xFE, 0x47, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D11FunctionParameterReflection : ID3D11FunctionP 0x8C, 0xC4, 0x62 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs index 927b8cf..763b567 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCB, 0xCE, 0x7B, 0x20, 0x83, 0xD6, 0x06, 0x4A, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection 0x9F, 0x73, 0xA4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11GeometryShader.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11GeometryShader.cs index ef6d7ef..0142295 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11GeometryShader.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11GeometryShader.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11GeometryShader : ID3D11GeometryShader.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x96, 0x5B, 0x32, 0x38, 0xFB, 0xEF, 0x22, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11GeometryShader : ID3D11GeometryShader.Interfa 0x70, 0x27, 0x5C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11HullShader.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11HullShader.cs index e357fe6..dde3dfc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11HullShader.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11HullShader.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11HullShader : ID3D11HullShader.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x61, 0x60, 0x5C, 0x8E, 0x8A, 0x62, 0x8E, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11HullShader : ID3D11HullShader.Interface, INat 0xB3, 0xD5, 0xDD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InfoQueue.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InfoQueue.cs index 598b0c3..e762716 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InfoQueue.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InfoQueue.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11InfoQueue : ID3D11InfoQueue.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB6, 0xDB, 0x43, 0x65, 0x48, 0x1B, 0xF5, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11InfoQueue : ID3D11InfoQueue.Interface, INativ 0x43, 0x26, 0xF6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InputLayout.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InputLayout.cs index 978509b..40fceb6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InputLayout.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11InputLayout.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11InputLayout : ID3D11InputLayout.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDC, 0x9D, 0x81, 0xE4, 0xF0, 0x4C, 0x25, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11InputLayout : ID3D11InputLayout.Interface, IN 0x3E, 0x07, 0xB7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs index 40eed4d..923d0c8 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11LibraryReflection : ID3D11LibraryReflection.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1B, 0x4F, 0x38, 0x54, 0x3E, 0x5B, 0xB7, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11LibraryReflection : ID3D11LibraryReflection.I 0x97, 0xCB, 0xB6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Linker.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Linker.cs index 4a7012e..4026dae 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Linker.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Linker.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Linker : ID3D11Linker.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0E, 0xCD, 0xA6, 0x59, 0x0D, 0xE1, 0x1F, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Linker : ID3D11Linker.Interface, INativeGuid 0xDA, 0xF3, 0x0E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LinkingNode.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LinkingNode.cs index 8c4720e..dc3eab0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LinkingNode.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LinkingNode.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11LinkingNode : ID3D11LinkingNode.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0C, 0xD7, 0x0D, 0xD8, 0x2F, 0x8D, 0x51, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11LinkingNode : ID3D11LinkingNode.Interface, IN 0x35, 0x56, 0xDB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Module.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Module.cs index 08fdaa4..3671cf9 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Module.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Module.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Module : ID3D11Module.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEE, 0x01, 0xC7, 0xCA, 0xFC, 0x80, 0x22, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Module : ID3D11Module.Interface, INativeGuid 0x8C, 0xEC, 0x34 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ModuleInstance.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ModuleInstance.cs index 7f7ce61..36ebe5f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ModuleInstance.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ModuleInstance.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ModuleInstance : ID3D11ModuleInstance.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF7, 0x07, 0x9E, 0x46, 0x5A, 0x04, 0xD5, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ModuleInstance : ID3D11ModuleInstance.Interfa 0xCD, 0xF7, 0x5D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Multithread.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Multithread.cs index 5797a4a..a014d40 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Multithread.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Multithread.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Multithread : ID3D11Multithread.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x00, 0x4E, 0x7E, 0x9B, 0x2C, 0x34, 0x06, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Multithread : ID3D11Multithread.Interface, IN 0xF6, 0x89, 0xF0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11PixelShader.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11PixelShader.cs index ea7e29b..ec5acfb 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11PixelShader.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11PixelShader.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11PixelShader : ID3D11PixelShader.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0D, 0xE4, 0x82, 0xEA, 0xDC, 0x51, 0x33, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11PixelShader : ID3D11PixelShader.Interface, IN 0x25, 0xAE, 0x8C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Predicate.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Predicate.cs index 6b0aada..b3f6e8a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Predicate.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Predicate.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Predicate : ID3D11Predicate.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDD, 0x76, 0xB5, 0x9E, 0x77, 0x9F, 0x86, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Predicate : ID3D11Predicate.Interface, INativ 0xE4, 0x90, 0xE2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query.cs index 527d2ce..bf59d51 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Query : ID3D11Query.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x47, 0x07, 0xC0, 0xD6, 0xB7, 0x87, 0x5E, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Query : ID3D11Query.Interface, INativeGuid 0x56, 0x0A, 0xFD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query1.cs index a4dfa60..bac95ed 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Query1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Query1 : ID3D11Query1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0x47, 0x1B, 0x63, 0xDC, 0x36, 0x1D, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Query1 : ID3D11Query1.Interface, INativeGuid 0xE6, 0x09, 0x16 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState.cs index ae4c4ac..41515a9 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RasterizerState : ID3D11RasterizerState.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x81, 0xAB, 0xB4, 0x9B, 0x1A, 0xAB, 0x8F, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RasterizerState : ID3D11RasterizerState.Inter 0x0B, 0x6E, 0xE7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState1.cs index fa512e5..8edb175 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RasterizerState1 : ID3D11RasterizerState1.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0xD7, 0x17, 0x12, 0x39, 0x50, 0x8C, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RasterizerState1 : ID3D11RasterizerState1.Int 0x6A, 0xFD, 0x6E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState2.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState2.cs index 428d91b..602eed2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RasterizerState2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RasterizerState2 : ID3D11RasterizerState2.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFB, 0x02, 0xBD, 0x6F, 0x9F, 0x20, 0xC4, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RasterizerState2 : ID3D11RasterizerState2.Int 0x86, 0xA6, 0xAC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefDefaultTrackingOptions.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefDefaultTrackingOptions.cs index d094086..4677132 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefDefaultTrackingOptions.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefDefaultTrackingOptions.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RefDefaultTrackingOptions : ID3D11RefDefaultT [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x15, 0x66, 0x91, 0x03, 0x44, 0xC6, 0x8C, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RefDefaultTrackingOptions : ID3D11RefDefaultT 0xE6, 0x3C, 0xA0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefTrackingOptions.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefTrackingOptions.cs index 74c1be9..1b01fd9 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefTrackingOptions.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RefTrackingOptions.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RefTrackingOptions : ID3D11RefTrackingOptions [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDF, 0xAC, 0x3D, 0x19, 0xB2, 0x0D, 0x05, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RefTrackingOptions : ID3D11RefTrackingOptions 0xC5, 0x6F, 0xD9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView.cs index 4449e83..0e62c91 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RenderTargetView : ID3D11RenderTargetView.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x67, 0xA0, 0xDB, 0xDF, 0x8D, 0x0B, 0x65, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RenderTargetView : ID3D11RenderTargetView.Int 0x6C, 0xC1, 0x64 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView1.cs index b6e6e76..737af9f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11RenderTargetView1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11RenderTargetView1 : ID3D11RenderTargetView1.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x23, 0x2E, 0xBE, 0xFF, 0x11, 0xF0, 0x8A, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11RenderTargetView1 : ID3D11RenderTargetView1.I 0xC5, 0xB9, 0x4B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Resource.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Resource.cs index 858a1b7..08ed22f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Resource.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Resource.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Resource : ID3D11Resource.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF3, 0x63, 0x8E, 0xDC, 0x2B, 0xD1, 0x52, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Resource : ID3D11Resource.Interface, INativeG 0x6A, 0x86, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SamplerState.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SamplerState.cs index 6ff77f6..31ad0b1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SamplerState.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SamplerState.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11SamplerState : ID3D11SamplerState.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0xEA, 0x6F, 0xDA, 0x4C, 0x56, 0x87, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11SamplerState : ID3D11SamplerState.Interface, 0xB4, 0xE3, 0xA5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs index 07725c4..e3900b8 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA1, 0x6C, 0x53, 0x8D, 0xCA, 0x0C, 0x56, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Int 0x75, 0x55, 0x84 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs index c648c2a..756cbd0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer : ID3D11Shader [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3D, 0xD6, 0x62, 0xEB, 0xDD, 0x93, 0x18, 0x43, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer : ID3D11Shader 0xD3, 0x71, 0xB8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs index 7e83dae..66f854e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6A, 0xFA, 0x6F, 0x6E, 0xAE, 0x9B, 0x13, 0x46, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection 0x50, 0x8C, 0x21 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs index 1a65958..a733c81 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D11ShaderReflectionVariable : ID3D11ShaderReflec [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x23, 0x39, 0xF2, 0x51, 0xE5, 0xF3, 0xD1, 0x4B, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D11ShaderReflectionVariable : ID3D11ShaderReflec 0xD8, 0xDB, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView.cs index 78d9408..2006d48 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ShaderResourceView : ID3D11ShaderResourceView [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE0, 0x6F, 0xE0, 0xB0, 0x92, 0x81, 0x1A, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ShaderResourceView : ID3D11ShaderResourceView 0x47, 0x10, 0xB2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView1.cs index 126afe3..487fafc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderResourceView1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ShaderResourceView1 : ID3D11ShaderResourceVie [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x87, 0x8B, 0x30, 0x91, 0x40, 0x90, 0x1D, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ShaderResourceView1 : ID3D11ShaderResourceVie 0xCE, 0x38, 0x02 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTrace.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTrace.cs index 82a2f20..0df2259 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTrace.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTrace.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ShaderTrace : ID3D11ShaderTrace.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE6, 0x13, 0xB0, 0x36, 0x11, 0x28, 0x45, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ShaderTrace : ID3D11ShaderTrace.Interface, IN 0x0D, 0xF1, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTraceFactory.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTraceFactory.cs index 6053960..28f77a3 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTraceFactory.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderTraceFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11ShaderTraceFactory : ID3D11ShaderTraceFactory [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x29, 0xD4, 0xBA, 0x1F, 0xAB, 0x66, 0xCC, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11ShaderTraceFactory : ID3D11ShaderTraceFactory 0x0E, 0x44, 0x59 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SwitchToRef.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SwitchToRef.cs index 5f9dd93..c800929 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SwitchToRef.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11SwitchToRef.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11SwitchToRef : ID3D11SwitchToRef.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE3, 0x37, 0xF3, 0x1E, 0xE7, 0x58, 0x83, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11SwitchToRef : ID3D11SwitchToRef.Interface, IN 0x5E, 0xD4, 0x7E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture1D.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture1D.cs index 2619f33..44ba9f8 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture1D.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture1D.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Texture1D : ID3D11Texture1D.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x27, 0x5C, 0xFB, 0xF8, 0xB3, 0xC6, 0x75, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Texture1D : ID3D11Texture1D.Interface, INativ 0xEF, 0x56, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D.cs index 39edfcf..05e29f0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Texture2D : ID3D11Texture2D.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF2, 0xAA, 0x15, 0x6F, 0x08, 0xD2, 0x89, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Texture2D : ID3D11Texture2D.Interface, INativ 0xD3, 0x4F, 0x9C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D1.cs index 51a1b42..502e1fa 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture2D1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Texture2D1 : ID3D11Texture2D1.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0x82, 0x21, 0x51, 0x33, 0x1E, 0x17, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Texture2D1 : ID3D11Texture2D1.Interface, INat 0x67, 0xE7, 0xBB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D.cs index 7800b88..a5bb8c8 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Texture3D : ID3D11Texture3D.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0x86, 0x7E, 0x03, 0x6D, 0xF5, 0x57, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Texture3D : ID3D11Texture3D.Interface, INativ 0x6E, 0x25, 0x0E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D1.cs index 6099c35..94ef85a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11Texture3D1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11Texture3D1 : ID3D11Texture3D1.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x83, 0x16, 0x71, 0x0C, 0x53, 0x28, 0x46, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11Texture3D1 : ID3D11Texture3D1.Interface, INat 0x39, 0xE4, 0x6A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11TracingDevice.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11TracingDevice.cs index c37f233..5ef91d3 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11TracingDevice.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11TracingDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11TracingDevice : ID3D11TracingDevice.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x71, 0xC7, 0x11, 0x19, 0x87, 0x15, 0x3E, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11TracingDevice : ID3D11TracingDevice.Interface 0xDE, 0x02, 0x68 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView.cs index a84500e..66326ca 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11UnorderedAccessView : ID3D11UnorderedAccessVi [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x09, 0xF5, 0xAC, 0x28, 0x5C, 0x7F, 0xF6, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11UnorderedAccessView : ID3D11UnorderedAccessVi 0x0A, 0x63, 0x80 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView1.cs index 83ce086..289e5fb 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11UnorderedAccessView1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11UnorderedAccessView1 : ID3D11UnorderedAccessV [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x53, 0x61, 0x3B, 0x7B, 0x86, 0xA8, 0x44, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11UnorderedAccessView1 : ID3D11UnorderedAccessV 0x50, 0x04, 0x03 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VertexShader.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VertexShader.cs index 0b2bdcb..2ace208 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VertexShader.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VertexShader.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VertexShader : ID3D11VertexShader.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x64, 0x1D, 0x30, 0x3B, 0x78, 0xD6, 0x89, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VertexShader : ID3D11VertexShader.Interface, 0x8B, 0x72, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext.cs index 0552389..3ee24cf 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoContext : ID3D11VideoContext.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x45, 0x1C, 0xF2, 0x61, 0x0E, 0x3C, 0x74, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoContext : ID3D11VideoContext.Interface, 0x9A, 0xD5, 0xE4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext1.cs index d982b87..e60c9b9 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoContext1 : ID3D11VideoContext1.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x26, 0xF0, 0xA7, 0xF8, 0xA5, 0x87, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoContext1 : ID3D11VideoContext1.Interface 0x57, 0x65, 0x1E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext2.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext2.cs index 8f8c193..2913e59 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoContext2 : ID3D11VideoContext2.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4C, 0x37, 0xE7, 0xC4, 0x43, 0x62, 0x1B, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoContext2 : ID3D11VideoContext2.Interface 0x40, 0xE2, 0x61 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext3.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext3.cs index a4c8224..4fbe857 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoContext3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoContext3 : ID3D11VideoContext3.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA0, 0xFA, 0xE2, 0xA9, 0x39, 0xCB, 0x8F, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoContext3 : ID3D11VideoContext3.Interface 0xDE, 0x67, 0x2E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoder.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoder.cs index d0b52cb..d8c8c3a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoder.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoDecoder : ID3D11VideoDecoder.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0x5B, 0x9C, 0x3C, 0x5D, 0x99, 0xD1, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoDecoder : ID3D11VideoDecoder.Interface, 0xDE, 0xD6, 0x5C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoderOutputView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoderOutputView.cs index 5d0e9ef..391c80f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoderOutputView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDecoderOutputView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoDecoderOutputView : ID3D11VideoDecoderOu [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEA, 0x1A, 0x93, 0xC2, 0x85, 0x2A, 0x20, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoDecoderOutputView : ID3D11VideoDecoderOu 0x25, 0x6E, 0x18 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice.cs index 7a31702..0ee8d6f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoDevice : ID3D11VideoDevice.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0x4D, 0xEC, 0x10, 0x5A, 0x97, 0x89, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoDevice : ID3D11VideoDevice.Interface, IN 0x0F, 0xE3, 0x33 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice1.cs index 75d6656..0e4dae9 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoDevice1 : ID3D11VideoDevice1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0x1D, 0xDA, 0x29, 0x21, 0x13, 0x54, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoDevice1 : ID3D11VideoDevice1.Interface, 0x86, 0x1F, 0x0F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice2.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice2.cs index 7245d3e..d7be5cd 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoDevice2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoDevice2 : ID3D11VideoDevice2.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0xCB, 0xC0, 0x59, 0xF0, 0x35, 0x70, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoDevice2 : ID3D11VideoDevice2.Interface, 0x90, 0x6A, 0x53 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessor.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessor.cs index d4d2edd..0963a75 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessor.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessor.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoProcessor : ID3D11VideoProcessor.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x52, 0x06, 0x7B, 0x1D, 0x5F, 0x18, 0xC6, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoProcessor : ID3D11VideoProcessor.Interfa 0xD4, 0xAE, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator.cs index 96b027d..094d7f5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator : ID3D11VideoProcess [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0x70, 0x62, 0x31, 0xAB, 0x53, 0x00, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator : ID3D11VideoProcess 0xAB, 0x45, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator1.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator1.cs index 29d8760..9f3e996 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorEnumerator1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator1 : ID3D11VideoProces [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF2, 0x17, 0x52, 0x46, 0x68, 0x55, 0xCF, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator1 : ID3D11VideoProces 0x53, 0x1C, 0xA1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorInputView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorInputView.cs index fed759b..c907f29 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorInputView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorInputView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoProcessorInputView : ID3D11VideoProcesso [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5F, 0x5A, 0xEC, 0x11, 0xDC, 0x51, 0x45, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoProcessorInputView : ID3D11VideoProcesso 0x30, 0x0E, 0xA5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorOutputView.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorOutputView.cs index 575870a..77765bc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorOutputView.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11VideoProcessorOutputView.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11VideoProcessorOutputView : ID3D11VideoProcess [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5E, 0x28, 0x48, 0xA0, 0xA9, 0x25, 0x27, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11VideoProcessorOutputView : ID3D11VideoProcess 0xC4, 0x42, 0x54 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11View.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11View.cs index 21991ef..d3a02e1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11View.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11View.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11View : ID3D11View.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x16, 0x12, 0x9D, 0x83, 0x2E, 0xBB, 0x2B, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11View : ID3D11View.Interface, INativeGuid 0xE0, 0x8E, 0xD1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DDeviceContextState.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DDeviceContextState.cs index 2e8a158..e42820f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DDeviceContextState.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DDeviceContextState.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3DDeviceContextState : ID3DDeviceContextState.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0x0D, 0x1E, 0x5C, 0x23, 0x7C, 0xF9, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3DDeviceContextState : ID3DDeviceContextState.Int 0xCE, 0xFF, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DUserDefinedAnnotation.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DUserDefinedAnnotation.cs index bd41aca..83471f6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DUserDefinedAnnotation.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3DUserDefinedAnnotation.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3DUserDefinedAnnotation : ID3DUserDefinedAnnotati [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8B, 0xAD, 0xDA, 0xB2, 0xD4, 0x03, 0xBF, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3DUserDefinedAnnotation : ID3DUserDefinedAnnotati 0x63, 0xD0, 0xAB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device.cs b/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device.cs index d852bc5..5b705d4 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11On12Device : ID3D11On12Device.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x73, 0x1E, 0x61, 0x85, 0xA9, 0x70, 0x0E, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11On12Device : ID3D11On12Device.Interface, INat 0x77, 0x79, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device1.cs b/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device1.cs index fe749d6..032e25d 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11On12Device1 : ID3D11On12Device1.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF4, 0x4D, 0xB6, 0xBD, 0x2F, 0xEA, 0x70, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11On12Device1 : ID3D11On12Device1.Interface, IN 0x58, 0xBB, 0x5D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device2.cs b/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device2.cs index e392d02..6725919 100644 --- a/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D11on12/Generated/ID3D11On12Device2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D11On12Device2 : ID3D11On12Device2.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x31, 0xF3, 0x90, 0xDC, 0x40, 0x47, 0xFA, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D11On12Device2 : ID3D11On12Device2.Interface, IN 0xB5, 0x82, 0x23 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Apis.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Apis.cs index 88a0e65..e1fb19c 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Apis.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Apis.cs @@ -561,7 +561,7 @@ public static partial class Apis public const uint D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; - public const uint D3D12_PREVIEW_SDK_VERSION = 714; + public const uint D3D12_PREVIEW_SDK_VERSION = 717; public const uint D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16; @@ -697,7 +697,7 @@ public static partial class Apis public const uint D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT = 2; - public const uint D3D12_SDK_VERSION = 614; + public const uint D3D12_SDK_VERSION = 616; public const uint D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES = 32; @@ -803,6 +803,10 @@ public static partial class Apis public const uint D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512; + public const uint D3D12_TIGHT_ALIGNMENT_MIN_COMMITTED_RESOURCE_ALIGNEMNT = 4096; + + public const uint D3D12_TIGHT_ALIGNMENT_MIN_PLACED_RESOURCE_ALIGNEMNT = 8; + public const uint D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536; public const uint D3D12_TRACKED_WORKLOAD_MAX_INSTANCES = 32; @@ -871,6 +875,8 @@ public static partial class Apis public const uint D3D12_WORK_GRAPHS_MAX_NODE_DEPTH = 32; + public const uint LUID_DEFINED = 1; + public const uint D3D12_SHADER_COMPONENT_MAPPING_MASK = 7; public const uint D3D12_SHADER_COMPONENT_MAPPING_SHIFT = 3; @@ -889,14 +895,12 @@ public static partial class Apis public const uint D3D12_ANISOTROPIC_FILTERING_BIT = 64; - public const uint LUID_DEFINED = 1; - public static ref readonly Guid D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4E, 0x08, 0xB0, 0x62, 0x0E, 0xC7, 0xAA, 0x4D, @@ -908,7 +912,7 @@ public static partial class Apis 0x5A, 0x04, 0x82 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -920,7 +924,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEB, 0x2A, 0x35, 0xF2, 0x84, 0xDD, 0xFE, 0x49, @@ -932,7 +936,7 @@ public static partial class Apis 0xCC, 0x1B, 0x4F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -944,7 +948,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB1, 0x16, 0x82, 0xE3, 0x8C, 0x3C, 0x33, 0x48, @@ -956,7 +960,7 @@ public static partial class Apis 0x5D, 0x96, 0xC8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -968,7 +972,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0xBB, 0x75, 0x4A, 0xF4, 0x9F, 0xD8, 0x4A, @@ -980,7 +984,7 @@ public static partial class Apis 0xDC, 0x5F, 0xF2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -992,7 +996,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0x6A, 0xDA, 0x7C, 0x3E, 0xA0, 0xC8, 0x49, @@ -1004,7 +1008,7 @@ public static partial class Apis 0x0E, 0x07, 0xCE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1016,7 +1020,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBF, 0x63, 0x48, 0x11, 0x86, 0xC3, 0xEE, 0x4A, @@ -1028,7 +1032,31 @@ public static partial class Apis 0x06, 0x29, 0x55 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_D3D12DSRDeviceFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x7E, 0xD2, 0x6D, 0xBB, + 0xA9, 0x94, + 0xA6, 0x41, + 0x9F, + 0x1B, + 0x13, + 0x37, + 0x72, + 0x17, + 0x24, + 0x28 + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1044,7 +1072,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0x2E, 0x90, 0xD4, 0x7A, 0x75, 0x42, 0x49, @@ -1056,7 +1084,7 @@ public static partial class Apis 0xFA, 0x43, 0xCD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1068,7 +1096,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8C, 0xA9, 0x59, 0xCF, 0x50, 0xA9, 0x26, 0x43, @@ -1080,7 +1108,7 @@ public static partial class Apis 0x7B, 0xFD, 0x95 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1140,7 +1168,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3E, 0x57, 0xF5, 0x76, 0x3A, 0xF1, 0xF5, 0x40, @@ -1152,7 +1180,7 @@ public static partial class Apis 0x18, 0x93, 0x3F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1164,7 +1192,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5F, 0x72, 0xC4, 0xC9, 0x1A, 0xA8, 0x56, 0x4F, @@ -1176,7 +1204,31 @@ public static partial class Apis 0xD6, 0x94, 0xFB - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D12GPUUploadHeapsOnUnsupportedOS + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xF3, 0x51, 0xDC, 0x45, + 0x7F, 0x76, + 0x88, 0x45, + 0xB2, + 0x06, + 0x0B, + 0xAA, + 0x2B, + 0x16, + 0xFB, + 0xAE + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1360,6 +1412,8 @@ public static partial class Apis public const Feature D3D12_FEATURE_PLACED_RESOURCE_SUPPORT_INFO = Feature.PlacedResourceSupportInfo; public const Feature D3D12_FEATURE_HARDWARE_COPY = Feature.HardwareCopy; public const Feature D3D12_FEATURE_D3D12_OPTIONS21 = Feature.Options21; + public const Feature D3D12_FEATURE_APPLICATION_SPECIFIC_DRIVER_STATE = Feature.ApplicationSpecificDriverState; + public const Feature D3D12_FEATURE_BYTECODE_BYPASS_HASH_SUPPORTED = Feature.BytecodeBypassHashSupported; public const ShaderMinPrecisionSupport D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = ShaderMinPrecisionSupport.None; public const ShaderMinPrecisionSupport D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = ShaderMinPrecisionSupport.P10Bit; public const ShaderMinPrecisionSupport D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = ShaderMinPrecisionSupport.P16Bit; @@ -1479,6 +1533,7 @@ public static partial class Apis public const RaytracingTier D3D12_RAYTRACING_TIER_NOT_SUPPORTED = RaytracingTier.NotSupported; public const RaytracingTier D3D12_RAYTRACING_TIER_1_0 = RaytracingTier.Tier1_0; public const RaytracingTier D3D12_RAYTRACING_TIER_1_1 = RaytracingTier.Tier1_1; + public const RaytracingTier D3D12_RAYTRACING_TIER_1_2 = RaytracingTier.Tier1_2; public const VariableShadingRateTier D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = VariableShadingRateTier.NotSupported; public const VariableShadingRateTier D3D12_VARIABLE_SHADING_RATE_TIER_1 = VariableShadingRateTier.Tier1; public const VariableShadingRateTier D3D12_VARIABLE_SHADING_RATE_TIER_2 = VariableShadingRateTier.Tier2; @@ -1886,6 +1941,7 @@ public static partial class Apis public const RaytracingPipelineFlags D3D12_RAYTRACING_PIPELINE_FLAG_NONE = RaytracingPipelineFlags.None; public const RaytracingPipelineFlags D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = RaytracingPipelineFlags.SkipTriangles; public const RaytracingPipelineFlags D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = RaytracingPipelineFlags.SkipProceduralPrimitives; + public const RaytracingPipelineFlags D3D12_RAYTRACING_PIPELINE_FLAG_ALLOW_OPACITY_MICROMAPS = RaytracingPipelineFlags.AllowOpacityMicromaps; public const NodeOverridesType D3D12_NODE_OVERRIDES_TYPE_NONE = NodeOverridesType.None; public const NodeOverridesType D3D12_NODE_OVERRIDES_TYPE_BROADCASTING_LAUNCH = NodeOverridesType.BroadcastingLaunch; public const NodeOverridesType D3D12_NODE_OVERRIDES_TYPE_COALESCING_LAUNCH = NodeOverridesType.CoalescingLaunch; @@ -1902,11 +1958,24 @@ public static partial class Apis public const RaytracingGeometryFlags D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = RaytracingGeometryFlags.NoDuplicateAnyhitInvocation; public const RaytracingGeometryType D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = RaytracingGeometryType.Triangles; public const RaytracingGeometryType D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = RaytracingGeometryType.ProceduralPrimitiveAabbs; + public const RaytracingGeometryType D3D12_RAYTRACING_GEOMETRY_TYPE_OMM_TRIANGLES = RaytracingGeometryType.OmmTriangles; public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_NONE = RaytracingInstanceFlags.None; public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = RaytracingInstanceFlags.TriangleCullDisable; public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = RaytracingInstanceFlags.TriangleFrontCounterclockwise; public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = RaytracingInstanceFlags.ForceOpaque; public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = RaytracingInstanceFlags.ForceNonOpaque; + public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OMM_2_STATE = RaytracingInstanceFlags.ForceOmm2State; + public const RaytracingInstanceFlags D3D12_RAYTRACING_INSTANCE_FLAG_DISABLE_OMMS = RaytracingInstanceFlags.DisableOmms; + public const RaytracingOpacityMicromapSpecialIndex D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT = RaytracingOpacityMicromapSpecialIndex.FullyTransparent; + public const RaytracingOpacityMicromapSpecialIndex D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE = RaytracingOpacityMicromapSpecialIndex.FullyOpaque; + public const RaytracingOpacityMicromapSpecialIndex D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT = RaytracingOpacityMicromapSpecialIndex.FullyUnknownTransparent; + public const RaytracingOpacityMicromapSpecialIndex D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE = RaytracingOpacityMicromapSpecialIndex.FullyUnknownOpaque; + public const RaytracingOpacityMicromapState D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_TRANSPARENT = RaytracingOpacityMicromapState.Transparent; + public const RaytracingOpacityMicromapState D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_OPAQUE = RaytracingOpacityMicromapState.Opaque; + public const RaytracingOpacityMicromapState D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT = RaytracingOpacityMicromapState.UnknownTransparent; + public const RaytracingOpacityMicromapState D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE = RaytracingOpacityMicromapState.UnknownOpaque; + public const RaytracingOpacityMicromapFormat D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_2_STATE = RaytracingOpacityMicromapFormat.Oc12State; + public const RaytracingOpacityMicromapFormat D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_4_STATE = RaytracingOpacityMicromapFormat.Oc14State; public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = RaytracingAccelerationStructureBuildFlags.None; public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = RaytracingAccelerationStructureBuildFlags.AllowUpdate; public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = RaytracingAccelerationStructureBuildFlags.AllowCompaction; @@ -1914,6 +1983,8 @@ public static partial class Apis public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = RaytracingAccelerationStructureBuildFlags.PreferFastBuild; public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = RaytracingAccelerationStructureBuildFlags.MinimizeMemory; public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = RaytracingAccelerationStructureBuildFlags.PerformUpdate; + public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_UPDATE = RaytracingAccelerationStructureBuildFlags.AllowOmmUpdate; + public const RaytracingAccelerationStructureBuildFlags D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_DISABLE_OMMS = RaytracingAccelerationStructureBuildFlags.AllowDisableOmms; public const RaytracingAccelerationStructureCopyMode D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = RaytracingAccelerationStructureCopyMode.Clone; public const RaytracingAccelerationStructureCopyMode D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = RaytracingAccelerationStructureCopyMode.Compact; public const RaytracingAccelerationStructureCopyMode D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = RaytracingAccelerationStructureCopyMode.VisualizationDecodeForTools; @@ -1921,6 +1992,7 @@ public static partial class Apis public const RaytracingAccelerationStructureCopyMode D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = RaytracingAccelerationStructureCopyMode.Deserialize; public const RaytracingAccelerationStructureType D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = RaytracingAccelerationStructureType.TopLevel; public const RaytracingAccelerationStructureType D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = RaytracingAccelerationStructureType.BottomLevel; + public const RaytracingAccelerationStructureType D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_ARRAY = RaytracingAccelerationStructureType.OpacityMicromapArray; public const ElementsLayout D3D12_ELEMENTS_LAYOUT_ARRAY = ElementsLayout.Array; public const ElementsLayout D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = ElementsLayout.ArrayOfPointers; public const RaytracingAccelerationStructurePostbuildInfoType D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = RaytracingAccelerationStructurePostbuildInfoType.CompactedSize; @@ -1928,11 +2000,18 @@ public static partial class Apis public const RaytracingAccelerationStructurePostbuildInfoType D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = RaytracingAccelerationStructurePostbuildInfoType.Serialization; public const RaytracingAccelerationStructurePostbuildInfoType D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = RaytracingAccelerationStructurePostbuildInfoType.CurrentSize; public const SerializedDataType D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = SerializedDataType.RaytracingAccelerationStructure; + public const SerializedDataType D3D12_SERIALIZED_DATA_APPLICATION_SPECIFIC_DRIVER_STATE = SerializedDataType.ApplicationSpecificDriverState; public const DriverMatchingIdentifierStatus D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = DriverMatchingIdentifierStatus.CompatibleWithDevice; public const DriverMatchingIdentifierStatus D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = DriverMatchingIdentifierStatus.UnsupportedType; public const DriverMatchingIdentifierStatus D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = DriverMatchingIdentifierStatus.Unrecognized; public const DriverMatchingIdentifierStatus D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = DriverMatchingIdentifierStatus.IncompatibleVersion; public const DriverMatchingIdentifierStatus D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = DriverMatchingIdentifierStatus.IncompatibleType; + public const SerializedRaytracingAccelerationStructureHeaderPostambleType D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_NONE = SerializedRaytracingAccelerationStructureHeaderPostambleType.None; + public const SerializedRaytracingAccelerationStructureHeaderPostambleType D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BOTTOM_LEVEL_POINTERS = SerializedRaytracingAccelerationStructureHeaderPostambleType.BottomLevelPointers; + public const SerializedRaytracingAccelerationStructureHeaderPostambleType D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BLOCKS = SerializedRaytracingAccelerationStructureHeaderPostambleType.Blocks; + public const SerializedBlockType D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAPS = SerializedBlockType.D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAPS; + public const RaytracingOpacityMicromapArrayPostbuildInfoType D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE = RaytracingOpacityMicromapArrayPostbuildInfoType.D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE; + public const RaytracingOpacityMicromapArrayPostbuildInfoType D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION = RaytracingOpacityMicromapArrayPostbuildInfoType.D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION; public const RayFlags D3D12_RAY_FLAG_NONE = RayFlags.None; public const RayFlags D3D12_RAY_FLAG_FORCE_OPAQUE = RayFlags.ForceOpaque; public const RayFlags D3D12_RAY_FLAG_FORCE_NON_OPAQUE = RayFlags.ForceNonOpaque; @@ -1944,6 +2023,7 @@ public static partial class Apis public const RayFlags D3D12_RAY_FLAG_CULL_NON_OPAQUE = RayFlags.CullNonOpaque; public const RayFlags D3D12_RAY_FLAG_SKIP_TRIANGLES = RayFlags.SkipTriangles; public const RayFlags D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = RayFlags.SkipProceduralPrimitives; + public const RayFlags D3D12_RAY_FLAG_FORCE_OMM_2_STATE = RayFlags.ForceOmm2State; public const HitKind D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = HitKind.TriangleFrontFace; public const HitKind D3D12_HIT_KIND_TRIANGLE_BACK_FACE = HitKind.TriangleBackFace; public const AutoBreadcrumbOperation D3D12_AUTO_BREADCRUMB_OP_SETMARKER = AutoBreadcrumbOperation.SetMarker; @@ -1995,6 +2075,7 @@ public static partial class Apis public const AutoBreadcrumbOperation D3D12_AUTO_BREADCRUMB_OP_BEGIN_COMMAND_LIST = AutoBreadcrumbOperation.BeginCommandList; public const AutoBreadcrumbOperation D3D12_AUTO_BREADCRUMB_OP_DISPATCHGRAPH = AutoBreadcrumbOperation.Dispatchgraph; public const AutoBreadcrumbOperation D3D12_AUTO_BREADCRUMB_OP_SETPROGRAM = AutoBreadcrumbOperation.Setprogram; + public const AutoBreadcrumbOperation D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES2 = AutoBreadcrumbOperation.Processframes2; public const DredVersion D3D12_DRED_VERSION_1_0 = DredVersion.V1_0; public const DredVersion D3D12_DRED_VERSION_1_1 = DredVersion.V1_1; public const DredVersion D3D12_DRED_VERSION_1_2 = DredVersion.V1_2; @@ -2176,6 +2257,10 @@ public static partial class Apis public const ShaderCacheControlFlags D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = ShaderCacheControlFlags.Disable; public const ShaderCacheControlFlags D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = ShaderCacheControlFlags.Enable; public const ShaderCacheControlFlags D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = ShaderCacheControlFlags.Clear; + public const ApplicationSpecificDriverBlobStatus D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_UNKNOWN = ApplicationSpecificDriverBlobStatus.D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_UNKNOWN; + public const ApplicationSpecificDriverBlobStatus D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_USED = ApplicationSpecificDriverBlobStatus.D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_USED; + public const ApplicationSpecificDriverBlobStatus D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_IGNORED = ApplicationSpecificDriverBlobStatus.D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_IGNORED; + public const ApplicationSpecificDriverBlobStatus D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_NOT_SPECIFIED = ApplicationSpecificDriverBlobStatus.D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_NOT_SPECIFIED; public const GpuBasedValidationFlags D3D12_GPU_BASED_VALIDATION_FLAGS_NONE = GpuBasedValidationFlags.None; public const GpuBasedValidationFlags D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING = GpuBasedValidationFlags.DisableStateTracking; public const ReportLiveDeviceObjectFlags D3D12_RLDO_NONE = ReportLiveDeviceObjectFlags.None; @@ -2185,6 +2270,7 @@ public static partial class Apis public const DebugDeviceParameterType D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS = DebugDeviceParameterType.FeatureFlags; public const DebugDeviceParameterType D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = DebugDeviceParameterType.GpuBasedValidationSettings; public const DebugDeviceParameterType D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = DebugDeviceParameterType.GpuSlowdownPerformanceFactor; + public const DebugDeviceParameterType D3D12_DEBUG_DEVICE_PARAMETER_BYTECODE_VALIDATION_MODE = DebugDeviceParameterType.BytecodeValidationMode; public const DebugFeature D3D12_DEBUG_FEATURE_NONE = DebugFeature.None; public const DebugFeature D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = DebugFeature.AllowBehaviorChangingDebugAids; public const DebugFeature D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING = DebugFeature.ConservativeResourceStateTracking; @@ -2200,6 +2286,10 @@ public static partial class Apis public const GpuBasedValidationPipelineStateCreateFlags D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = GpuBasedValidationPipelineStateCreateFlags.FrontLoadCreateUnguardedValidationShaders; public const GpuBasedValidationPipelineStateCreateFlags D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = GpuBasedValidationPipelineStateCreateFlags.FrontLoadCreateGuardedValidationShaders; public const GpuBasedValidationPipelineStateCreateFlags D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK = GpuBasedValidationPipelineStateCreateFlags.ValidMask; + public const DebugDeviceBytecodeValidationMode D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED = DebugDeviceBytecodeValidationMode.D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED; + public const DebugDeviceBytecodeValidationMode D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED = DebugDeviceBytecodeValidationMode.D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED; + public const DebugDeviceBytecodeValidationMode D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE = DebugDeviceBytecodeValidationMode.D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE; + public const DebugDeviceBytecodeValidationMode D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE_DEFAULT = DebugDeviceBytecodeValidationMode.Default; public const DebugCommandListParameterType D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = DebugCommandListParameterType.GpuBasedValidationSettings; public const MessageCategory D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED = MessageCategory.ApplicationDefined; public const MessageCategory D3D12_MESSAGE_CATEGORY_MISCELLANEOUS = MessageCategory.Miscellaneous; @@ -3202,6 +3292,11 @@ public static partial class Apis public const MessageId D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INSTANCE_COUNT_ZERO = MessageId.CommandListDrawInstanceCountZero; public const MessageId D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SET_BEFORE_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG = MessageId.DescriptorHeapNotSetBeforeRootSignatureWithDirectlyIndexedFlag; public const MessageId D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG = MessageId.DifferentDescriptorHeapSetAfterRootSignatureWithDirectlyIndexedFlag; + public const MessageId D3D12_MESSAGE_ID_APPLICATION_SPECIFIC_DRIVER_STATE_NOT_SUPPORTED = MessageId.ApplicationSpecificDriverStateNotSupported; + public const MessageId D3D12_MESSAGE_ID_RENDER_TARGET_OR_DEPTH_STENCIL_RESOUCE_NOT_INITIALIZED = MessageId.RenderTargetOrDepthStencilResouceNotInitialized; + public const MessageId D3D12_MESSAGE_ID_BYTECODE_VALIDATION_ERROR = MessageId.BytecodeValidationError; + public const MessageId D3D12_MESSAGE_ID_FENCE_ZERO_WAIT = MessageId.FenceZeroWait; + public const MessageId D3D12_MESSAGE_ID_NON_COMMON_RESOURCE_IN_COPY_QUEUE = MessageId.NonCommonResourceInCopyQueue; public const MessageCallbackFlags D3D12_MESSAGE_CALLBACK_FLAG_NONE = MessageCallbackFlags.None; public const MessageCallbackFlags D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS = MessageCallbackFlags.IgnoreFilters; public const DeviceFactoryFlags D3D12_DEVICE_FACTORY_FLAG_NONE = DeviceFactoryFlags.None; diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Enums.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Enums.cs index 1576ca7..7be710e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Enums.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Enums.cs @@ -668,6 +668,12 @@ public enum Feature /// /// D3D12_FEATURE_D3D12_OPTIONS21 Options21 = 53, + /// + /// D3D12_FEATURE_APPLICATION_SPECIFIC_DRIVER_STATE + ApplicationSpecificDriverState = 56, + /// + /// D3D12_FEATURE_BYTECODE_BYPASS_HASH_SUPPORTED + BytecodeBypassHashSupported = 57, } /// @@ -1151,6 +1157,9 @@ public enum RaytracingTier /// /// D3D12_RAYTRACING_TIER_1_1 Tier1_1 = 11, + /// + /// D3D12_RAYTRACING_TIER_1_2 + Tier1_2 = 12, } /// @@ -2831,6 +2840,9 @@ public enum RaytracingPipelineFlags /// /// D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES SkipProceduralPrimitives = 512, + /// + /// D3D12_RAYTRACING_PIPELINE_FLAG_ALLOW_OPACITY_MICROMAPS + AllowOpacityMicromaps = 1024, } /// @@ -2917,6 +2929,9 @@ public enum RaytracingGeometryType /// /// D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS ProceduralPrimitiveAabbs = 1, + /// + /// D3D12_RAYTRACING_GEOMETRY_TYPE_OMM_TRIANGLES + OmmTriangles = 2, } /// @@ -2939,6 +2954,60 @@ public enum RaytracingInstanceFlags /// /// D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE ForceNonOpaque = 8, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OMM_2_STATE + ForceOmm2State = 16, + /// + /// D3D12_RAYTRACING_INSTANCE_FLAG_DISABLE_OMMS + DisableOmms = 32, +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX +public enum RaytracingOpacityMicromapSpecialIndex +{ + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT + FullyTransparent = -1, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE + FullyOpaque = -2, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT + FullyUnknownTransparent = -3, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE + FullyUnknownOpaque = -4, +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_STATE +public enum RaytracingOpacityMicromapState +{ + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_TRANSPARENT + Transparent = 0, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_OPAQUE + Opaque = 1, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT + UnknownTransparent = 2, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE + UnknownOpaque = 3, +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT +public enum RaytracingOpacityMicromapFormat +{ + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_2_STATE + Oc12State = 1, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_4_STATE + Oc14State = 2, } /// @@ -2967,6 +3036,12 @@ public enum RaytracingAccelerationStructureBuildFlags /// /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE PerformUpdate = 32, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_UPDATE + AllowOmmUpdate = 64, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_DISABLE_OMMS + AllowDisableOmms = 128, } /// @@ -3000,6 +3075,9 @@ public enum RaytracingAccelerationStructureType /// /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL BottomLevel = 1, + /// + /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_ARRAY + OpacityMicromapArray = 2, } /// @@ -3039,6 +3117,9 @@ public enum SerializedDataType /// /// D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE RaytracingAccelerationStructure = 0, + /// + /// D3D12_SERIALIZED_DATA_APPLICATION_SPECIFIC_DRIVER_STATE + ApplicationSpecificDriverState = 1, } /// @@ -3062,6 +3143,42 @@ public enum DriverMatchingIdentifierStatus IncompatibleType = 4, } +/// +/// D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE +public enum SerializedRaytracingAccelerationStructureHeaderPostambleType +{ + /// + /// D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_NONE + None = 0, + /// + /// D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BOTTOM_LEVEL_POINTERS + BottomLevelPointers = 0, + /// + /// D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BLOCKS + Blocks = -1, +} + +/// +/// D3D12_SERIALIZED_BLOCK_TYPE +public enum SerializedBlockType +{ + /// + /// D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAPS + D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAPS = 0, +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE +public enum RaytracingOpacityMicromapArrayPostbuildInfoType +{ + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE + D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE = 0, + /// + /// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION + D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION = 1, +} + /// /// D3D12_RAY_FLAGS [Flags] @@ -3100,6 +3217,9 @@ public enum RayFlags /// /// D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES SkipProceduralPrimitives = 512, + /// + /// D3D12_RAY_FLAG_FORCE_OMM_2_STATE + ForceOmm2State = 1024, } /// @@ -3265,6 +3385,9 @@ public enum AutoBreadcrumbOperation /// /// D3D12_AUTO_BREADCRUMB_OP_SETPROGRAM Setprogram = 48, + /// + /// D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES2 + Processframes2 = 52, } /// @@ -3961,6 +4084,24 @@ public enum ShaderCacheControlFlags Clear = 4, } +/// +/// D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS +public enum ApplicationSpecificDriverBlobStatus +{ + /// + /// D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_UNKNOWN + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_UNKNOWN = 1, + /// + /// D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_USED + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_USED = 2, + /// + /// D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_IGNORED + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_IGNORED = 3, + /// + /// D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_NOT_SPECIFIED + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_NOT_SPECIFIED = 4, +} + /// /// D3D12_GPU_BASED_VALIDATION_FLAGS [Flags] @@ -4006,6 +4147,9 @@ public enum DebugDeviceParameterType /// /// D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR GpuSlowdownPerformanceFactor = 2, + /// + /// D3D12_DEBUG_DEVICE_PARAMETER_BYTECODE_VALIDATION_MODE + BytecodeValidationMode = 3, } /// @@ -4073,6 +4217,24 @@ public enum GpuBasedValidationPipelineStateCreateFlags ValidMask = 7, } +/// +/// D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE +public enum DebugDeviceBytecodeValidationMode +{ + /// + /// D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED = 0, + /// + /// D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED = 1, + /// + /// D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE = 2, + /// + /// D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE_DEFAULT + Default = 1, +} + /// /// D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE public enum DebugCommandListParameterType @@ -7101,6 +7263,21 @@ public enum MessageId /// /// D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG DifferentDescriptorHeapSetAfterRootSignatureWithDirectlyIndexedFlag = 1420, + /// + /// D3D12_MESSAGE_ID_APPLICATION_SPECIFIC_DRIVER_STATE_NOT_SUPPORTED + ApplicationSpecificDriverStateNotSupported = 1421, + /// + /// D3D12_MESSAGE_ID_RENDER_TARGET_OR_DEPTH_STENCIL_RESOUCE_NOT_INITIALIZED + RenderTargetOrDepthStencilResouceNotInitialized = 1422, + /// + /// D3D12_MESSAGE_ID_BYTECODE_VALIDATION_ERROR + BytecodeValidationError = 1423, + /// + /// D3D12_MESSAGE_ID_FENCE_ZERO_WAIT + FenceZeroWait = 1424, + /// + /// D3D12_MESSAGE_ID_NON_COMMON_RESOURCE_IN_COPY_QUEUE + NonCommonResourceInCopyQueue = 1425, } /// diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Structs.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Structs.cs index 02ae2b4..26866a3 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Structs.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/Graphics.Direct3D12.Structs.cs @@ -1225,6 +1225,22 @@ public partial struct FeatureDataHardwareCopy public Bool32 Supported; } +/// +/// D3D12_FEATURE_DATA_APPLICATION_SPECIFIC_DRIVER_STATE +public partial struct FeatureDataApplicationSpecificDriverState +{ + /// + public Bool32 Supported; +} + +/// +/// D3D12_FEATURE_DATA_BYTECODE_BYPASS_HASH_SUPPORTED +public partial struct FeatureDataBytecodeBypassHashSupported +{ + /// + public Bool32 Supported; +} + /// /// D3D12_RESOURCE_ALLOCATION_INFO public partial struct ResourceAllocationInfo @@ -3650,6 +3666,26 @@ public partial struct IndirectArgumentDescription [FieldOffset(0)] public _Anonymous_e__Union._IncrementingConstant_e__Struct IncrementingConstant; + public partial struct _UnorderedAccessView_e__Struct + { + /// + public uint RootParameterIndex; + } + public partial struct _ConstantBufferView_e__Struct + { + /// + public uint RootParameterIndex; + } + public partial struct _VertexBuffer_e__Struct + { + /// + public uint Slot; + } + public partial struct _ShaderResourceView_e__Struct + { + /// + public uint RootParameterIndex; + } public partial struct _IncrementingConstant_e__Struct { /// @@ -3658,11 +3694,6 @@ public partial struct IndirectArgumentDescription /// public uint DestOffsetIn32BitValues; } - public partial struct _ShaderResourceView_e__Struct - { - /// - public uint RootParameterIndex; - } public partial struct _Constant_e__Struct { /// @@ -3674,21 +3705,6 @@ public partial struct IndirectArgumentDescription /// public uint Num32BitValuesToSet; } - public partial struct _UnorderedAccessView_e__Struct - { - /// - public uint RootParameterIndex; - } - public partial struct _VertexBuffer_e__Struct - { - /// - public uint Slot; - } - public partial struct _ConstantBufferView_e__Struct - { - /// - public uint RootParameterIndex; - } } } @@ -4381,6 +4397,45 @@ public partial struct RaytracingGeometryAabbsDescription public GpuVirtualAddressAndStride AABBs; } +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_DESC +public partial struct RaytracingOpacityMicromapDescription +{ + /// + public uint ByteOffset; + + /// + public uint _bitfield; +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC +public partial struct RaytracingGeometryOmmLinkageDescription +{ + /// + public GpuVirtualAddressAndStride OpacityMicromapIndexBuffer; + + /// + public Graphics.Dxgi.Common.Format OpacityMicromapIndexFormat; + + /// + public uint OpacityMicromapBaseLocation; + + /// + public ulong OpacityMicromapArray; +} + +/// +/// D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC +public partial struct RaytracingGeometryOmmTrianglesDescription +{ + /// + public unsafe RaytracingGeometryTrianglesDescription* pTriangles; + + /// + public unsafe RaytracingGeometryOmmLinkageDescription* pOmmLinkage; +} + /// /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC public partial struct RaytracingAccelerationStructurePostbuildInfoDescription @@ -4426,8 +4481,40 @@ public partial struct RaytracingAccelerationStructurePostbuildInfoSerializationD /// public ulong SerializedSizeInBytes; - /// - public ulong NumBottomLevelAccelerationStructurePointers; + /// + public _Anonymous_e__Union Anonymous; + + [UnscopedRef] + public ref ulong NumBottomLevelAccelerationStructurePointers + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref Anonymous.NumBottomLevelAccelerationStructurePointers; + } + } + + [UnscopedRef] + public ref ulong NumBottomLevelAccelerationStructureHeaderAndPointerListPairs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref Anonymous.NumBottomLevelAccelerationStructureHeaderAndPointerListPairs; + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public ulong NumBottomLevelAccelerationStructurePointers; + + /// + [FieldOffset(0)] + public ulong NumBottomLevelAccelerationStructureHeaderAndPointerListPairs; + } } /// @@ -4458,6 +4545,69 @@ public partial struct SerializedRaytracingAccelerationStructureHeader public ulong NumBottomLevelAccelerationStructurePointersAfterHeader; } +/// +/// D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER1 +public partial struct SerializedRaytracingAccelerationStructureHeader1 +{ + /// + public SerializedDataDriverMatchingIdentifier DriverMatchingIdentifier; + + /// + public ulong SerializedSizeInBytesIncludingHeader; + + /// + public ulong DeserializedSizeInBytes; + + /// + public _Anonymous_e__Union Anonymous; + + /// + public SerializedRaytracingAccelerationStructureHeaderPostambleType HeaderPostambleType; + + [UnscopedRef] + public ref uint NumBottomLevelAccelerationStructurePointersAfterHeader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref Anonymous.NumBottomLevelAccelerationStructurePointersAfterHeader; + } + } + + [UnscopedRef] + public ref uint NumBlocks + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref Anonymous.NumBlocks; + } + } + + [StructLayout(LayoutKind.Explicit)] + public partial struct _Anonymous_e__Union + { + /// + [FieldOffset(0)] + public uint NumBottomLevelAccelerationStructurePointersAfterHeader; + + /// + [FieldOffset(0)] + public uint NumBlocks; + } +} + +/// +/// D3D12_RAYTRACING_SERIALIZED_BLOCK +public partial struct RaytracingSerializedBlock +{ + /// + public SerializedBlockType Type; + + /// + public ulong NumBlockPointersAfterHeader; +} + /// /// D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC public partial struct RaytracingAccelerationStructurePostbuildInfoCurrentSizeDescription @@ -4516,6 +4666,16 @@ public partial struct RaytracingGeometryDescription } } + [UnscopedRef] + public ref RaytracingGeometryOmmTrianglesDescription OmmTriangles + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref Anonymous.OmmTriangles; + } + } + [StructLayout(LayoutKind.Explicit)] public partial struct _Anonymous_e__Union { @@ -4526,9 +4686,44 @@ public partial struct RaytracingGeometryDescription /// [FieldOffset(0)] public RaytracingGeometryAabbsDescription AABBs; + + /// + [FieldOffset(0)] + public RaytracingGeometryOmmTrianglesDescription OmmTriangles; } } +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY +public partial struct RaytracingOpacityMicromapHistogramEntry +{ + /// + public uint Count; + + /// + public uint SubdivisionLevel; + + /// + public RaytracingOpacityMicromapFormat Format; +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC +public partial struct RaytracingOpacityMicromapArrayDescription +{ + /// + public uint NumOmmHistogramEntries; + + /// + public unsafe RaytracingOpacityMicromapHistogramEntry* pOmmHistogram; + + /// + public ulong InputBuffer; + + /// + public GpuVirtualAddressAndStride PerOmmDescs; +} + /// /// D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS public partial struct BuildRaytracingAccelerationStructureInputs @@ -4578,6 +4773,16 @@ public partial struct BuildRaytracingAccelerationStructureInputs } } + [UnscopedRef] + public unsafe ref RaytracingOpacityMicromapArrayDescription* pOpacityMicromapArrayDesc + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref Anonymous.pOpacityMicromapArrayDesc; + } + } + [StructLayout(LayoutKind.Explicit)] public partial struct _Anonymous_e__Union { @@ -4592,6 +4797,10 @@ public partial struct BuildRaytracingAccelerationStructureInputs /// [FieldOffset(0)] public unsafe RaytracingGeometryDescription** ppGeometryDescs; + + /// + [FieldOffset(0)] + public unsafe RaytracingOpacityMicromapArrayDescription* pOpacityMicromapArrayDesc; } } @@ -4626,6 +4835,33 @@ public partial struct RaytracingAccelerationStructurePrebuildInfo public ulong UpdateScratchDataSizeInBytes; } +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC +public partial struct RaytracingOpacityMicromapArrayPostbuildInfoDescription +{ + /// + public ulong DestBuffer; + + /// + public RaytracingOpacityMicromapArrayPostbuildInfoType InfoType; +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC +public partial struct RaytracingOpacityMicromapArrayPostbuildInfoCurrentSizeDescription +{ + /// + public ulong CurrentSizeInBytes; +} + +/// +/// D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC +public partial struct RaytracingOpacityMicromapArrayPostbuildInfoToolsVisualizationDescription +{ + /// + public ulong DecodedSizeInBytes; +} + /// /// D3D12_AUTO_BREADCRUMB_NODE public partial struct AutoBreadcrumbNode diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandAllocator.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandAllocator.cs index dcac7d4..4565c09 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandAllocator.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandAllocator.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12CommandAllocator : ID3D12CommandAllocator.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE4, 0xDE, 0x02, 0x61, 0x59, 0xAF, 0x09, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12CommandAllocator : ID3D12CommandAllocator.Int 0xF0, 0x9B, 0x24 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandList.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandList.cs index dfe8b98..fc03fd6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandList.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandList.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12CommandList : ID3D12CommandList.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1C, 0xD9, 0x16, 0x71, 0xE4, 0xE7, 0xCE, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12CommandList : ID3D12CommandList.Interface, IN 0xF4, 0x37, 0xE5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandQueue.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandQueue.cs index c74dd98..59cc855 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandQueue.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandQueue.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12CommandQueue : ID3D12CommandQueue.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0x70, 0xC8, 0x0E, 0x7E, 0x5D, 0x22, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12CommandQueue : ID3D12CommandQueue.Interface, 0x76, 0x16, 0xED - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandSignature.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandSignature.cs index c753107..9d3bb16 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandSignature.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12CommandSignature.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12CommandSignature : ID3D12CommandSignature.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7C, 0x79, 0x6A, 0xC3, 0x80, 0xEC, 0x0A, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12CommandSignature : ID3D12CommandSignature.Int 0x50, 0x82, 0xD1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DSRDeviceFactory.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DSRDeviceFactory.cs new file mode 100644 index 0000000..0f79ba7 --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DSRDeviceFactory.cs @@ -0,0 +1,87 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D12; + +/// +/// ID3D12DSRDeviceFactory +[Guid("f343d1a0-afe3-439f-b13d-cd87a43b70ca")] +[NativeTypeName("struct ID3D12DSRDeviceFactory : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DSRDeviceFactory : ID3D12DSRDeviceFactory.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3D12DSRDeviceFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xA0, 0xD1, 0x43, 0xF3, + 0xE3, 0xAF, + 0x9F, 0x43, + 0xB1, + 0x3D, + 0xCD, + 0x87, + 0xA4, + 0x3B, + 0x70, + 0xCA + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D12DSRDeviceFactory)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3D12DSRDeviceFactory*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3D12DSRDeviceFactory*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3D12DSRDeviceFactory*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateDSRDevice(ID3D12Device* pD3D12Device, uint NodeMask, Guid* riid, void** ppvDSRDevice) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3D12DSRDeviceFactory*)Unsafe.AsPointer(ref this), pD3D12Device, NodeMask, riid, ppvDSRDevice); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + HResult CreateDSRDevice(ID3D12Device* pD3D12Device, uint NodeMask, Guid* riid, void** ppvDSRDevice); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug.cs index 6e5d626..fca33a6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug : ID3D12Debug.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB7, 0x88, 0x44, 0x34, 0x46, 0x68, 0x4B, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug : ID3D12Debug.Interface, INativeGuid 0x82, 0x45, 0xE0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug1.cs index b87db90..268fcbd 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug1 : ID3D12Debug1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0xA4, 0xFA, 0xAF, 0xFE, 0x63, 0x8E, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug1 : ID3D12Debug1.Interface, INativeGuid 0xAF, 0x43, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug2.cs index 68b35d8..1670617 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug2 : ID3D12Debug2.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0x65, 0xA6, 0x93, 0xB2, 0xA3, 0x5D, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug2 : ID3D12Debug2.Interface, INativeGuid 0x4E, 0x33, 0x74 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug3.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug3.cs index b240915..5ed97c8 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug3 : ID3D12Debug3.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8F, 0xE5, 0xF4, 0x5C, 0x71, 0xF6, 0xF1, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug3 : ID3D12Debug3.Interface, INativeGuid 0xD1, 0x53, 0xD1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug4.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug4.cs index cfee0ab..aefb36d 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug4.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug4 : ID3D12Debug4.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0x81, 0x4B, 0x01, 0xC5, 0x9E, 0x2F, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug4 : ID3D12Debug4.Interface, INativeGuid 0x1C, 0xE1, 0x3A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug5.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug5.cs index cc2dc8b..ec79d85 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug5.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug5 : ID3D12Debug5.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x12, 0x6B, 0x8D, 0x54, 0xFA, 0x09, 0xE0, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug5 : ID3D12Debug5.Interface, INativeGuid 0x9A, 0x52, 0xC9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug6.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug6.cs index a23ccae..de96fec 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug6.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Debug6.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Debug6 : ID3D12Debug6.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0x16, 0xA8, 0x82, 0x01, 0x5D, 0x57, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Debug6 : ID3D12Debug6.Interface, INativeGuid 0x3F, 0xD1, 0xED - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList.cs index 104e691..26b0607 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugCommandList : ID3D12DebugCommandList.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0xBF, 0xE0, 0x09, 0xAC, 0x54, 0x4F, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugCommandList : ID3D12DebugCommandList.Int 0xB6, 0x05, 0x3F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList1.cs index cf0501f..55c2bb0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugCommandList1 : ID3D12DebugCommandList1.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0xA9, 0x2C, 0x10, 0x1B, 0x31, 0x01, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugCommandList1 : ID3D12DebugCommandList1.I 0x06, 0x1B, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList2.cs index 1778204..a731d06 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugCommandList2 : ID3D12DebugCommandList2.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCF, 0x75, 0xB5, 0xAE, 0x06, 0x4E, 0xBE, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugCommandList2 : ID3D12DebugCommandList2.I 0x96, 0x65, 0x2E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList3.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList3.cs index 6ce064b..12ca21d 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandList3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugCommandList3 : ID3D12DebugCommandList3.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x15, 0x5E, 0x7D, 0x19, 0x37, 0x4D, 0x34, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugCommandList3 : ID3D12DebugCommandList3.I 0x0F, 0xDB, 0x1F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue.cs index 46240e7..acba037 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugCommandQueue : ID3D12DebugCommandQueue.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0xBF, 0xE0, 0x09, 0xAC, 0x54, 0x4F, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugCommandQueue : ID3D12DebugCommandQueue.I 0xB6, 0x05, 0x3A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue1.cs index b5a3de5..ea63795 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugCommandQueue1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugCommandQueue1 : ID3D12DebugCommandQueue1 [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0x35, 0xBE, 0x16, 0xD6, 0xBF, 0xF2, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugCommandQueue1 : ID3D12DebugCommandQueue1 0xFF, 0x86, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice.cs index f7285bb..a5230a0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugDevice : ID3D12DebugDevice.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDD, 0xD6, 0xEB, 0x3F, 0x73, 0x49, 0x87, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugDevice : ID3D12DebugDevice.Interface, IN 0x28, 0x92, 0x3E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice1.cs index 5dfe726..efaa153 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugDevice1 : ID3D12DebugDevice1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x70, 0x17, 0xB7, 0xA9, 0x99, 0xD0, 0x65, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugDevice1 : ID3D12DebugDevice1.Interface, 0x02, 0x0F, 0x88 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice2.cs index 1b66416..4ec75c4 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DebugDevice2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DebugDevice2 : ID3D12DebugDevice2.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC1, 0xCB, 0xEC, 0x60, 0x8D, 0x37, 0xF1, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DebugDevice2 : ID3D12DebugDevice2.Interface, 0xE4, 0xD7, 0xDD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DescriptorHeap.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DescriptorHeap.cs index 9ef8d2f..63f52f4 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DescriptorHeap.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DescriptorHeap.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DescriptorHeap : ID3D12DescriptorHeap.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1D, 0x47, 0xFB, 0x8E, 0x6C, 0x61, 0x49, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DescriptorHeap : ID3D12DescriptorHeap.Interfa 0x63, 0xFA, 0x51 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device.cs index 5fee66f..ad7cab7 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device : ID3D12Device.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF1, 0x19, 0x98, 0x18, 0xB6, 0x1D, 0x57, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device : ID3D12Device.Interface, INativeGuid 0x9B, 0x85, 0xF7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device1.cs index 25f4248..0ce8240 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device1 : ID3D12Device1.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x80, 0xCE, 0xAC, 0x77, 0x8E, 0x63, 0x65, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device1 : ID3D12Device1.Interface, INativeGui 0x86, 0x86, 0x3E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device10.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device10.cs index 4ad7f73..0a9c164 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device10.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device10.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device10 : ID3D12Device10.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x18, 0x87, 0x7F, 0x51, 0x66, 0xAA, 0xF9, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device10 : ID3D12Device10.Interface, INativeG 0xC0, 0x60, 0x31 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device11.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device11.cs index c2d56e8..7bccedf 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device11.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device11.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device11 : ID3D12Device11.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x44, 0xC3, 0x05, 0x54, 0x57, 0xD4, 0x4E, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device11 : ID3D12Device11.Interface, INativeG 0x5A, 0xEE, 0x39 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device12.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device12.cs index 4d3edcf..2c445e2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device12.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device12.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device12 : ID3D12Device12.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x32, 0xC5, 0xF5, 0x5A, 0x91, 0x4C, 0xD0, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device12 : ID3D12Device12.Interface, INativeG 0x39, 0x5F, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device13.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device13.cs index bb2c673..8a92840 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device13.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device13.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device13 : ID3D12Device13.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFC, 0xCF, 0xEE, 0x14, 0xF8, 0x4D, 0xF7, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device13 : ID3D12Device13.Interface, INativeG 0x45, 0x69, 0x5E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device14.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device14.cs index a904366..b1ab19a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device14.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device14.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device14 : ID3D12Device14.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2D, 0x59, 0x6E, 0x5F, 0x95, 0xD8, 0xC2, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device14 : ID3D12Device14.Interface, INativeG 0x26, 0xD3, 0x23 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device2.cs index c0e6f1b..d05e32f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device2 : ID3D12Device2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1E, 0xA4, 0xBA, 0x30, 0x5B, 0xB1, 0x5C, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device2 : ID3D12Device2.Interface, INativeGui 0xB6, 0x43, 0x28 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device3.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device3.cs index efa95f5..dd54b00 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device3 : ID3D12Device3.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x15, 0xDC, 0xDA, 0x81, 0xAD, 0x2B, 0x92, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device3 : ID3D12Device3.Interface, INativeGui 0xC4, 0xAA, 0x98 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device4.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device4.cs index 5672d63..1e58690 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device4.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device4 : ID3D12Device4.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x17, 0xDF, 0x65, 0xE8, 0xEE, 0xA9, 0xF9, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device4 : ID3D12Device4.Interface, INativeGui 0x5A, 0xA2, 0xE5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device5.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device5.cs index 74413ba..584920a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device5.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device5 : ID3D12Device5.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3B, 0x17, 0x4F, 0x8B, 0xEA, 0x2F, 0x80, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device5 : ID3D12Device5.Interface, INativeGui 0x1A, 0xB9, 0x5D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device6.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device6.cs index 8ac5bdb..439658f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device6.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device6.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device6 : ID3D12Device6.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1B, 0x22, 0x0B, 0xC7, 0xE4, 0x40, 0x17, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device6 : ID3D12Device6.Interface, INativeGui 0x27, 0xA6, 0xDC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device7.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device7.cs index e152b0f..49a79c6 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device7.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device7.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device7 : ID3D12Device7.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x53, 0x4B, 0x01, 0x5C, 0xA1, 0x68, 0x9B, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device7 : ID3D12Device7.Interface, INativeGui 0xB9, 0x35, 0x8B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device8.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device8.cs index c918ad2..22911ce 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device8.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device8.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device8 : ID3D12Device8.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBB, 0xE6, 0x18, 0x92, 0x44, 0xF9, 0x7E, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device8 : ID3D12Device8.Interface, INativeGui 0xB7, 0x01, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device9.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device9.cs index 1cec46a..b497048 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device9.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Device9.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Device9 : ID3D12Device9.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0xE9, 0x80, 0x4C, 0x32, 0xF0, 0x60, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Device9 : ID3D12Device9.Interface, INativeGui 0xA1, 0xD8, 0x3C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceChild.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceChild.cs index 4683cc3..16a97d1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceChild.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceChild.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceChild : ID3D12DeviceChild.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4B, 0xB9, 0x5D, 0x90, 0x0C, 0xA0, 0x40, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceChild : ID3D12DeviceChild.Interface, IN 0x9E, 0xA3, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration.cs index 096cf51..cfab492 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceConfiguration : ID3D12DeviceConfigurati [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7B, 0xF8, 0xDB, 0x78, 0x66, 0xF7, 0x2B, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceConfiguration : ID3D12DeviceConfigurati 0xBD, 0xB9, 0xAD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration1.cs index c401b72..578237d 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceConfiguration1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceConfiguration1 : ID3D12DeviceConfigurat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x42, 0x24, 0x34, 0xED, 0x43, 0x63, 0x16, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceConfiguration1 : ID3D12DeviceConfigurat 0x87, 0x4E, 0x56 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceFactory.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceFactory.cs index 416228c..f287300 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceFactory.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceFactory : ID3D12DeviceFactory.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD3, 0x07, 0xF3, 0x61, 0x4E, 0xD3, 0x7C, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceFactory : ID3D12DeviceFactory.Interface 0x23, 0xCC, 0xCB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData.cs index addbec3..85ac8fc 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData : ID3D12DeviceRemov [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x33, 0x1D, 0x93, 0x98, 0xE8, 0x5A, 0x91, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData : ID3D12DeviceRemov 0x93, 0x4E, 0x71 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData1.cs index dc1a5b7..6dd942f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemo [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x22, 0xA0, 0x27, 0x97, 0x1D, 0xCF, 0xDA, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemo 0x3F, 0xC5, 0x06 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData2.cs index c2ee190..3cb3c7b 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedData2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemo [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x16, 0x58, 0xFC, 0x67, 0xCA, 0xE4, 0x15, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemo 0x72, 0xDA, 0x54 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings.cs index 4cf4e73..433d18f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings : ID3D12Dev [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1C, 0x48, 0xBC, 0x82, 0x9B, 0x6B, 0x30, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings : ID3D12Dev 0xDF, 0x1E, 0x63 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings1.cs index 6db8e9c..259d50d 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12De [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0xAE, 0xD5, 0xDB, 0x17, 0x33, 0x0A, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12De 0xCA, 0xAE, 0x0B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings2.cs index 36bf513..e08a059 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceRemovedExtendedDataSettings2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings2 : ID3D12De [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x88, 0x23, 0x55, 0x61, 0xAB, 0x01, 0x08, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings2 : ID3D12De 0x95, 0x66, 0xEA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceTools.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceTools.cs new file mode 100644 index 0000000..338b2bb --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceTools.cs @@ -0,0 +1,87 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D12; + +/// +/// ID3D12DeviceTools +[Guid("2ea68e9c-19c3-4e47-a109-6cdadff0aca9")] +[NativeTypeName("struct ID3D12DeviceTools : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12DeviceTools : ID3D12DeviceTools.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3D12DeviceTools + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x9C, 0x8E, 0xA6, 0x2E, + 0xC3, 0x19, + 0x47, 0x4E, + 0xA1, + 0x09, + 0x6C, + 0xDA, + 0xDF, + 0xF0, + 0xAC, + 0xA9 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D12DeviceTools)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3D12DeviceTools*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3D12DeviceTools*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3D12DeviceTools*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void SetNextAllocationAddress(ulong nextAllocationVirtualAddress) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3D12DeviceTools*)Unsafe.AsPointer(ref this), nextAllocationVirtualAddress); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + void SetNextAllocationAddress(ulong nextAllocationVirtualAddress); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceTools1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceTools1.cs new file mode 100644 index 0000000..baf3a73 --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12DeviceTools1.cs @@ -0,0 +1,106 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D12; + +/// +/// ID3D12DeviceTools1 +[Guid("e30e9fc7-e641-4d6e-8a81-9dd9206ec47a")] +[NativeTypeName("struct ID3D12DeviceTools1 : ID3D12DeviceTools")] +[NativeInheritance("ID3D12DeviceTools")] +public unsafe partial struct ID3D12DeviceTools1 : ID3D12DeviceTools1.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3D12DeviceTools1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xC7, 0x9F, 0x0E, 0xE3, + 0x41, 0xE6, + 0x6E, 0x4D, + 0x8A, + 0x81, + 0x9D, + 0xD9, + 0x20, + 0x6E, + 0xC4, + 0x7A + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D12DeviceTools1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3D12DeviceTools1*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3D12DeviceTools1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3D12DeviceTools1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void SetNextAllocationAddress(ulong nextAllocationVirtualAddress) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3D12DeviceTools1*)Unsafe.AsPointer(ref this), nextAllocationVirtualAddress); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetApplicationSpecificDriverState(Graphics.Direct3D.ID3DBlob** ppBlob) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((ID3D12DeviceTools1*)Unsafe.AsPointer(ref this), ppBlob); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public ApplicationSpecificDriverBlobStatus GetApplicationSpecificDriverBlobStatus() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((ID3D12DeviceTools1*)Unsafe.AsPointer(ref this)); + } + + public interface Interface : ID3D12DeviceTools.Interface + { + [VtblIndex(4)] + HResult GetApplicationSpecificDriverState(Graphics.Direct3D.ID3DBlob** ppBlob); + + [VtblIndex(5)] + ApplicationSpecificDriverBlobStatus GetApplicationSpecificDriverBlobStatus(); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence.cs index 0f92ff4..933c5c8 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Fence : ID3D12Fence.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCF, 0x3D, 0x75, 0x0A, 0xD8, 0xC4, 0x91, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Fence : ID3D12Fence.Interface, INativeGuid 0xD9, 0x5A, 0x76 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence1.cs index e028876..72a4fe5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Fence1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Fence1 : ID3D12Fence1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFE, 0x85, 0x36, 0x43, 0x2B, 0xE2, 0xA0, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Fence1 : ID3D12Fence1.Interface, INativeGuid 0xDD, 0x0E, 0x4A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionParameterReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionParameterReflection.cs index 3b23849..5463dd1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionParameterReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionParameterReflection.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D12FunctionParameterReflection : ID3D12FunctionP [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2D, 0xF4, 0x25, 0xEC, 0x06, 0x70, 0x2B, 0x4F, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D12FunctionParameterReflection : ID3D12FunctionP 0x75, 0x73, 0x3F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs index 6480f31..7b0c5e9 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5C, 0x79, 0x08, 0x11, 0x72, 0x27, 0xA9, 0x4B, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection 0x7E, 0x27, 0x99 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GBVDiagnostics.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GBVDiagnostics.cs index e45e89d..d2521d1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GBVDiagnostics.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GBVDiagnostics.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GBVDiagnostics : ID3D12GBVDiagnostics.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAB, 0x85, 0x79, 0x59, 0x75, 0x9B, 0xBB, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GBVDiagnostics : ID3D12GBVDiagnostics.Interfa 0x5B, 0xEB, 0xEE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList.cs index 5271a08..0f7f677 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList : ID3D12GraphicsCommandLi [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0F, 0x0D, 0x16, 0x5B, 0x1B, 0xAC, 0x85, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList : ID3D12GraphicsCommandLi 0xA5, 0xA4, 0x55 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList1.cs index dee0076..13c769e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFB, 0x03, 0x31, 0x55, 0xE7, 0x1F, 0x57, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandL 0x0E, 0x7C, 0xA7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList10.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList10.cs index 93fbfe1..62ef456 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList10.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList10.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList10 : ID3D12GraphicsCommand [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x15, 0xC0, 0x13, 0x70, 0x61, 0xD1, 0x63, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList10 : ID3D12GraphicsCommand 0xDD, 0x8A, 0xCC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList2.cs index 0cd70ac..2d7577e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0xE5, 0xC3, 0x38, 0x17, 0xFF, 0x2C, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandL 0xD7, 0x2A, 0x28 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList3.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList3.cs index 8e0ac71..3f543b4 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList3.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList3.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA7, 0x83, 0xDA, 0x6F, 0x4C, 0xB8, 0x38, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandL 0x01, 0x6B, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList4.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList4.cs index af2a7af..7182c81 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList4.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList4.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8E, 0x31, 0x54, 0x87, 0xA9, 0xD3, 0x41, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandL 0xDC, 0x48, 0x74 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList5.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList5.cs index 7f91d07..48b5e65 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList5.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList5.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x59, 0x08, 0x05, 0x55, 0x24, 0x40, 0x4C, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandL 0xEE, 0x44, 0xEA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList6.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList6.cs index faed9b9..dd236b2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList6.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList6.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x90, 0x78, 0x82, 0xC3, 0x48, 0xE5, 0xFA, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandL 0x37, 0x0F, 0x80 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList7.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList7.cs index 7bd43ca..950a1ec 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList7.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList7.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList7 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x23, 0x12, 0x17, 0xDD, 0x61, 0x8B, 0x69, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList7 : ID3D12GraphicsCommandL 0xE4, 0xE2, 0xC1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList8.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList8.cs index 7345fad..29af5fb 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList8.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList8.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList8 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF9, 0x6E, 0x93, 0xEE, 0x9D, 0x59, 0x28, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList8 : ID3D12GraphicsCommandL 0x05, 0xCE, 0x51 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList9.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList9.cs index 7c353b6..da450ec 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList9.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12GraphicsCommandList9.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12GraphicsCommandList9 : ID3D12GraphicsCommandL [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x08, 0x28, 0xED, 0x34, 0xE6, 0xFF, 0x2B, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12GraphicsCommandList9 : ID3D12GraphicsCommandL 0x0C, 0x59, 0xE1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap.cs index ca9ac67..2c9ee78 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Heap : ID3D12Heap.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0x25, 0x3B, 0x6B, 0x51, 0x6E, 0xB3, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Heap : ID3D12Heap.Interface, INativeGuid 0x5E, 0x8D, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap1.cs index 03e12d9..619cdf2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Heap1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Heap1 : ID3D12Heap1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x89, 0x73, 0x2F, 0x57, 0x68, 0x21, 0xE3, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Heap1 : ID3D12Heap1.Interface, INativeGuid 0x71, 0xBF, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue.cs index 383c9a5..49c3ad5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12InfoQueue : ID3D12InfoQueue.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0B, 0xA9, 0x42, 0x07, 0x87, 0xC3, 0x3F, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12InfoQueue : ID3D12InfoQueue.Interface, INativ 0xE6, 0x14, 0x58 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue1.cs index 8ad2292..47b43c2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12InfoQueue1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12InfoQueue1 : ID3D12InfoQueue1.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x88, 0xDD, 0x52, 0x28, 0x84, 0xB4, 0x0C, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12InfoQueue1 : ID3D12InfoQueue1.Interface, INat 0x00, 0xE6, 0x00 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs index e28dd9a..40f6cf2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12LibraryReflection : ID3D12LibraryReflection.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0x9D, 0x34, 0x8E, 0xDB, 0x54, 0x56, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12LibraryReflection : ID3D12LibraryReflection.I 0xBD, 0xB8, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeOwner.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeOwner.cs index d0b75b2..013f078 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeOwner.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeOwner.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12LifetimeOwner : ID3D12LifetimeOwner.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0xAF, 0x67, 0xE6, 0x56, 0xCD, 0x46, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12LifetimeOwner : ID3D12LifetimeOwner.Interface 0x5D, 0x70, 0xA8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeTracker.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeTracker.cs index d2daeef..48c2c70 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeTracker.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LifetimeTracker.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12LifetimeTracker : ID3D12LifetimeTracker.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0x3D, 0xD0, 0x3F, 0xB1, 0x4E, 0x4A, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12LifetimeTracker : ID3D12LifetimeTracker.Inter 0x8B, 0xA8, 0x13 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ManualWriteTrackingResource.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ManualWriteTrackingResource.cs index 8c0f8e8..0e282a5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ManualWriteTrackingResource.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ManualWriteTrackingResource.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12ManualWriteTrackingResource : ID3D12ManualWri [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0x3B, 0xCA, 0x86, 0xAD, 0x49, 0x6E, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12ManualWriteTrackingResource : ID3D12ManualWri 0x54, 0x0F, 0x41 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12MetaCommand.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12MetaCommand.cs index dbca102..2b84b01 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12MetaCommand.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12MetaCommand.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12MetaCommand : ID3D12MetaCommand.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x27, 0x4C, 0xB8, 0xDB, 0xCE, 0x36, 0xC9, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12MetaCommand : ID3D12MetaCommand.Interface, IN 0x6A, 0xC5, 0x70 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Object.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Object.cs index 9948604..8767927 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Object.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Object.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Object : ID3D12Object.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8F, 0xC2, 0xFE, 0xC4, 0x66, 0x79, 0x95, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Object : ID3D12Object.Interface, INativeGuid 0x56, 0xC3, 0xB8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Pageable.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Pageable.cs index 6117c04..bf35010 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Pageable.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Pageable.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Pageable : ID3D12Pageable.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFB, 0x58, 0xEE, 0x63, 0x68, 0x12, 0x35, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Pageable : ID3D12Pageable.Interface, INativeG 0x62, 0xF0, 0xD6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PageableTools.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PageableTools.cs new file mode 100644 index 0000000..5a82bd9 --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PageableTools.cs @@ -0,0 +1,87 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D12; + +/// +/// ID3D12PageableTools +[Guid("8f1359db-d8d1-42f9-b5cf-79f4cbad0d3d")] +[NativeTypeName("struct ID3D12PageableTools : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct ID3D12PageableTools : ID3D12PageableTools.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3D12PageableTools + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xDB, 0x59, 0x13, 0x8F, + 0xD1, 0xD8, + 0xF9, 0x42, + 0xB5, + 0xCF, + 0x79, + 0xF4, + 0xCB, + 0xAD, + 0x0D, + 0x3D + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D12PageableTools)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3D12PageableTools*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3D12PageableTools*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3D12PageableTools*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetAllocation(GpuVirtualAddressRange* pAllocation) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3D12PageableTools*)Unsafe.AsPointer(ref this), pAllocation); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + HResult GetAllocation(GpuVirtualAddressRange* pAllocation); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary.cs index 888ba83..ea50e30 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12PipelineLibrary : ID3D12PipelineLibrary.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA8, 0x26, 0x42, 0xC6, 0x01, 0x92, 0xAF, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12PipelineLibrary : ID3D12PipelineLibrary.Inter 0xF7, 0x41, 0x4F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary1.cs index 3683712..8db73c0 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineLibrary1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12PipelineLibrary1 : ID3D12PipelineLibrary1.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x42, 0xBF, 0xEA, 0x80, 0x68, 0x25, 0x5E, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12PipelineLibrary1 : ID3D12PipelineLibrary1.Int 0x96, 0x1D, 0xC3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineState.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineState.cs index 69b8048..0ae8e3a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineState.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12PipelineState.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12PipelineState : ID3D12PipelineState.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF3, 0x30, 0x5A, 0x76, 0x24, 0xF6, 0x6F, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12PipelineState : ID3D12PipelineState.Interface 0x62, 0x24, 0x45 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession.cs index c3eabc0..6def63a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12ProtectedResourceSession : ID3D12ProtectedRes [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF4, 0x96, 0xD6, 0x6C, 0x89, 0xF2, 0xCC, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12ProtectedResourceSession : ID3D12ProtectedRes 0x09, 0x9C, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession1.cs index 0cfbf96..b0a27d5 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedResourceSession1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12ProtectedResourceSession1 : ID3D12ProtectedRe [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0x2D, 0xF1, 0xD6, 0xFB, 0x76, 0x6E, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12ProtectedResourceSession1 : ID3D12ProtectedRe 0xFC, 0x04, 0x09 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedSession.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedSession.cs index df03f61..3fa0d07 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedSession.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ProtectedSession.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12ProtectedSession : ID3D12ProtectedSession.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x18, 0x3D, 0x53, 0xA1, 0xC1, 0x0A, 0x84, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12ProtectedSession : ID3D12ProtectedSession.Int 0x16, 0x80, 0x6B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12QueryHeap.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12QueryHeap.cs index c7e2369..eec6346 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12QueryHeap.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12QueryHeap.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12QueryHeap : ID3D12QueryHeap.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAE, 0x58, 0x96, 0x0D, 0x45, 0xED, 0x9E, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12QueryHeap : ID3D12QueryHeap.Interface, INativ 0x83, 0xCA, 0xB4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource.cs index 6e4bb01..004e46f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Resource : ID3D12Resource.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBE, 0x42, 0x64, 0x69, 0x2E, 0xA7, 0x59, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Resource : ID3D12Resource.Interface, INativeG 0x04, 0x0F, 0xAD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource1.cs index 4ae04db..a843dc1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Resource1 : ID3D12Resource1.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7A, 0x22, 0x5E, 0x9D, 0x30, 0x44, 0x61, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Resource1 : ID3D12Resource1.Interface, INativ 0xB1, 0x6E, 0x19 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource2.cs index e212c46..197d4b1 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource2.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Resource2.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Resource2 : ID3D12Resource2.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3B, 0xEC, 0x36, 0xBE, 0x85, 0xEA, 0xEB, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Resource2 : ID3D12Resource2.Interface, INativ 0x04, 0xA4, 0x95 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignature.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignature.cs index 89f016b..175d27e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignature.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignature.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12RootSignature : ID3D12RootSignature.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0x6B, 0x4A, 0xC5, 0xDF, 0x72, 0xE8, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12RootSignature : ID3D12RootSignature.Interface 0x42, 0x92, 0x14 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignatureDeserializer.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignatureDeserializer.cs index 799c54e..b4dd97f 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignatureDeserializer.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12RootSignatureDeserializer.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12RootSignatureDeserializer : ID3D12RootSignatu [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7B, 0x64, 0xAB, 0x34, 0xC8, 0x3C, 0xAC, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12RootSignatureDeserializer : ID3D12RootSignatu 0x45, 0xC0, 0x46 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration.cs index 992e79d..e18a06e 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12SDKConfiguration : ID3D12SDKConfiguration.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x14, 0x53, 0xEB, 0xE9, 0xAA, 0x33, 0xB2, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12SDKConfiguration : ID3D12SDKConfiguration.Int 0xB1, 0xF1, 0xC7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration1.cs index 4a545a3..7fc79bb 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SDKConfiguration1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12SDKConfiguration1 : ID3D12SDKConfiguration1.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x03, 0x93, 0xAF, 0x8A, 0x25, 0xAD, 0xB9, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12SDKConfiguration1 : ID3D12SDKConfiguration1.I 0x00, 0x9D, 0x9F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderCacheSession.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderCacheSession.cs index 11a3100..13edb1d 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderCacheSession.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderCacheSession.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12ShaderCacheSession : ID3D12ShaderCacheSession [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5D, 0x49, 0xE2, 0x28, 0x64, 0x0F, 0xE4, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12ShaderCacheSession : ID3D12ShaderCacheSession 0xDC, 0x49, 0xA8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs index f0632e4..7d9de3c 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7D, 0x79, 0x58, 0x5A, 0x2C, 0xA7, 0x8D, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Int 0xEF, 0xE8, 0x8E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs index d01675d..e89fa28 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer : ID3D12Shader [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB4, 0x98, 0x95, 0xC5, 0xB3, 0x48, 0x69, 0x48, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer : ID3D12Shader 0x14, 0xA8, 0xB7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs index da97441..cdad658 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0xC3, 0x13, 0xE9, 0x3D, 0x78, 0xCA, 0x48, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection 0x84, 0xAD, 0x56 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs index 959059b..0749a44 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs @@ -19,7 +19,7 @@ public unsafe partial struct ID3D12ShaderReflectionVariable : ID3D12ShaderReflec [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0xA8, 0x37, 0x83, 0x16, 0xA2, 0x4A, 0x44, @@ -31,7 +31,7 @@ public unsafe partial struct ID3D12ShaderReflectionVariable : ID3D12ShaderReflec 0xA7, 0x3A, 0xEA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SharingContract.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SharingContract.cs index e59a7f7..679e7b2 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SharingContract.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SharingContract.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12SharingContract : ID3D12SharingContract.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x52, 0x7D, 0xDF, 0x0A, 0x9C, 0x92, 0x61, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12SharingContract : ID3D12SharingContract.Inter 0xDE, 0x66, 0xEF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObject.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObject.cs index 5178307..bca39fd 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObject.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObject.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12StateObject : ID3D12StateObject.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x43, 0x69, 0x01, 0x47, 0xA8, 0xFC, 0x94, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12StateObject : ID3D12StateObject.Interface, IN 0x55, 0x34, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties.cs index 631826c..ae53bda 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12StateObjectProperties : ID3D12StateObjectProp [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x27, 0xA8, 0x5F, 0xDE, 0xF9, 0x9B, 0x26, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12StateObjectProperties : ID3D12StateObjectProp 0xDE, 0x38, 0x60 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties1.cs index aef6d92..224948b 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties1.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12StateObjectProperties1.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12StateObjectProperties1 : ID3D12StateObjectPro [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC7, 0xAA, 0x0C, 0x46, 0x24, 0x1D, 0x6A, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12StateObjectProperties1 : ID3D12StateObjectPro 0x49, 0x41, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SwapChainAssistant.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SwapChainAssistant.cs index 250c033..6685228 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SwapChainAssistant.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12SwapChainAssistant.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12SwapChainAssistant : ID3D12SwapChainAssistant [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB6, 0x64, 0xDF, 0xF1, 0xFD, 0x57, 0xCD, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12SwapChainAssistant : ID3D12SwapChainAssistant 0xB4, 0x5C, 0x8F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools.cs index 3fa500e..5183859 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12Tools : ID3D12Tools.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF0, 0xE1, 0x71, 0x70, 0x4B, 0xE8, 0x33, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12Tools : ID3D12Tools.Interface, INativeGuid 0xDE, 0x65, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools1.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools1.cs new file mode 100644 index 0000000..daab2ea --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools1.cs @@ -0,0 +1,114 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D12; + +/// +/// ID3D12Tools1 +[Guid("e4fbc019-dd3c-43e1-8f32-7f649575f0a0")] +[NativeTypeName("struct ID3D12Tools1 : ID3D12Tools")] +[NativeInheritance("ID3D12Tools")] +public unsafe partial struct ID3D12Tools1 : ID3D12Tools1.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3D12Tools1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x19, 0xC0, 0xFB, 0xE4, + 0x3C, 0xDD, + 0xE1, 0x43, + 0x8F, + 0x32, + 0x7F, + 0x64, + 0x95, + 0x75, + 0xF0, + 0xA0 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D12Tools1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3D12Tools1*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3D12Tools1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3D12Tools1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void EnableShaderInstrumentation(Bool32 bEnable) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3D12Tools1*)Unsafe.AsPointer(ref this), bEnable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Bool32 ShaderInstrumentationEnabled() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((ID3D12Tools1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ReserveGPUVARangesAtCreate(GpuVirtualAddressRange* pRanges, uint uiNumRanges) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((ID3D12Tools1*)Unsafe.AsPointer(ref this), pRanges, uiNumRanges); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void ClearReservedGPUVARangesList() + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((ID3D12Tools1*)Unsafe.AsPointer(ref this)); + } + + public interface Interface : ID3D12Tools.Interface + { + [VtblIndex(5)] + HResult ReserveGPUVARangesAtCreate(GpuVirtualAddressRange* pRanges, uint uiNumRanges); + + [VtblIndex(6)] + void ClearReservedGPUVARangesList(); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools2.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools2.cs new file mode 100644 index 0000000..86f2524 --- /dev/null +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12Tools2.cs @@ -0,0 +1,119 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Direct3D12; + +/// +/// ID3D12Tools2 +[Guid("01d393c5-c9b0-42a1-958c-c26b02d4d097")] +[NativeTypeName("struct ID3D12Tools2 : ID3D12Tools1")] +[NativeInheritance("ID3D12Tools1")] +public unsafe partial struct ID3D12Tools2 : ID3D12Tools2.Interface, INativeGuid +{ + public static ref readonly Guid IID_ID3D12Tools2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xC5, 0x93, 0xD3, 0x01, + 0xB0, 0xC9, + 0xA1, 0x42, + 0x95, + 0x8C, + 0xC2, + 0x6B, + 0x02, + 0xD4, + 0xD0, + 0x97 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_ID3D12Tools2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((ID3D12Tools2*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((ID3D12Tools2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((ID3D12Tools2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void EnableShaderInstrumentation(Bool32 bEnable) + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((ID3D12Tools2*)Unsafe.AsPointer(ref this), bEnable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Bool32 ShaderInstrumentationEnabled() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((ID3D12Tools2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ReserveGPUVARangesAtCreate(GpuVirtualAddressRange* pRanges, uint uiNumRanges) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((ID3D12Tools2*)Unsafe.AsPointer(ref this), pRanges, uiNumRanges); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void ClearReservedGPUVARangesList() + { + ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((ID3D12Tools2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetApplicationSpecificDriverState(IUnknown* pAdapter, Graphics.Direct3D.ID3DBlob* pBlob) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[7]))((ID3D12Tools2*)Unsafe.AsPointer(ref this), pAdapter, pBlob); + } + + public interface Interface : ID3D12Tools1.Interface + { + [VtblIndex(7)] + HResult SetApplicationSpecificDriverState(IUnknown* pAdapter, Graphics.Direct3D.ID3DBlob* pBlob); + } +} + diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VersionedRootSignatureDeserializer.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VersionedRootSignatureDeserializer.cs index 2d8a4c8..d961a28 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VersionedRootSignatureDeserializer.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VersionedRootSignatureDeserializer.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12VersionedRootSignatureDeserializer : ID3D12Ve [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x67, 0xCE, 0x91, 0x7F, 0x0C, 0x09, 0xB7, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12VersionedRootSignatureDeserializer : ID3D12Ve 0xE3, 0x1D, 0xA0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VirtualizationGuestDevice.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VirtualizationGuestDevice.cs index 6dae677..cd539ce 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VirtualizationGuestDevice.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12VirtualizationGuestDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12VirtualizationGuestDevice : ID3D12Virtualizat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x68, 0xD3, 0x66, 0xBC, 0x73, 0x73, 0x43, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12VirtualizationGuestDevice : ID3D12Virtualizat 0x79, 0xE4, 0x76 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12WorkGraphProperties.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12WorkGraphProperties.cs index ec3a182..7f2008a 100644 --- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12WorkGraphProperties.cs +++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12WorkGraphProperties.cs @@ -21,7 +21,7 @@ public unsafe partial struct ID3D12WorkGraphProperties : ID3D12WorkGraphProperti [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x71, 0xCF, 0x5A, 0x06, 0x63, 0xF8, 0x89, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct ID3D12WorkGraphProperties : ID3D12WorkGraphProperti 0x88, 0x67, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAffineTransform2DEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAffineTransform2DEffect.cs index 19ea09c..0152565 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAffineTransform2DEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAffineTransform2DEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionAffineTransform2DEffect : IDCompositio [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE8, 0xB9, 0x74, 0x0B, 0xD6, 0xCD, 0x2F, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionAffineTransform2DEffect : IDCompositio 0x57, 0x02, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAnimation.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAnimation.cs index 5ca7a26..83cf272 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAnimation.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionAnimation.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionAnimation : IDCompositionAnimation.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD9, 0x91, 0xFD, 0xCB, 0xB2, 0x51, 0xE4, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionAnimation : IDCompositionAnimation.Int 0xB8, 0x63, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionArithmeticCompositeEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionArithmeticCompositeEffect.cs index b09e3f6..f63311d 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionArithmeticCompositeEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionArithmeticCompositeEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionArithmeticCompositeEffect : IDComposit [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA8, 0xDF, 0x67, 0x3B, 0xDD, 0xE3, 0x61, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionArithmeticCompositeEffect : IDComposit 0xD7, 0x39, 0xDC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBlendEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBlendEffect.cs index a11716d..7ab6d95 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBlendEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBlendEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionBlendEffect : IDCompositionBlendEffect [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0A, 0xDC, 0xEC, 0x33, 0x8A, 0x57, 0x11, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionBlendEffect : IDCompositionBlendEffect 0x17, 0xF9, 0xC5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBrightnessEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBrightnessEffect.cs index e4e756e..d68b6b0 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBrightnessEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionBrightnessEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionBrightnessEffect : IDCompositionBright [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0x49, 0x27, 0x60, 0x3A, 0xCB, 0xAB, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionBrightnessEffect : IDCompositionBright 0x4F, 0x7D, 0xA6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionClip.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionClip.cs index 337c86b..655423b 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionClip.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionClip.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionClip : IDCompositionClip.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x03, 0x37, 0xAC, 0x64, 0x3F, 0x9D, 0xEC, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionClip : IDCompositionClip.Interface, IN 0x7A, 0x13, 0xA7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionColorMatrixEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionColorMatrixEffect.cs index c8a181c..16469eb 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionColorMatrixEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionColorMatrixEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionColorMatrixEffect : IDCompositionColor [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x22, 0x0A, 0x17, 0xC1, 0xE2, 0x3C, 0x66, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionColorMatrixEffect : IDCompositionColor 0xFC, 0x84, 0xC4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionCompositeEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionCompositeEffect.cs index af5d881..3de11d8 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionCompositeEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionCompositeEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionCompositeEffect : IDCompositionComposi [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC0, 0x16, 0x66, 0x57, 0x31, 0xA2, 0x4D, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionCompositeEffect : IDCompositionComposi 0xC4, 0xDB, 0x46 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDelegatedInkTrail.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDelegatedInkTrail.cs index 16894eb..46bd0cc 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDelegatedInkTrail.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDelegatedInkTrail.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDelegatedInkTrail : IDCompositionDeleg [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9B, 0x8E, 0x44, 0xC2, 0x7D, 0x54, 0x57, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDelegatedInkTrail : IDCompositionDeleg 0xE1, 0xC2, 0xDA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDesktopDevice.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDesktopDevice.cs index 0efc5cc..60e9411 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDesktopDevice.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDesktopDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDesktopDevice : IDCompositionDesktopDe [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFE, 0x33, 0x46, 0x5F, 0x08, 0x1E, 0xB8, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDesktopDevice : IDCompositionDesktopDe 0x3F, 0x56, 0x02 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice.cs index 9d4674a..8d04d5e 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDevice : IDCompositionDevice.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3A, 0xA9, 0x7E, 0xC3, 0xAA, 0xE7, 0x0D, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDevice : IDCompositionDevice.Interface 0x04, 0x07, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice2.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice2.cs index 0a965f6..5e064b6 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice2.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDevice2 : IDCompositionDevice2.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8D, 0x46, 0xF6, 0x75, 0x8E, 0x1B, 0x7C, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDevice2 : IDCompositionDevice2.Interfa 0x0B, 0x5B, 0x25 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice3.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice3.cs index 4c56b61..3e11538 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice3.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDevice3 : IDCompositionDevice3.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x06, 0xCB, 0x87, 0x09, 0x16, 0xF9, 0xBF, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDevice3 : IDCompositionDevice3.Interfa 0x78, 0x1B, 0xD9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice4.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice4.cs index dd6e079..e7ec844 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice4.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDevice4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDevice4 : IDCompositionDevice4.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0x5C, 0xFC, 0x85, 0xA6, 0x2D, 0x4C, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDevice4 : IDCompositionDevice4.Interfa 0x04, 0x9B, 0x8A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDeviceDebug.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDeviceDebug.cs index 12fef71..9f2b456 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDeviceDebug.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionDeviceDebug.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionDeviceDebug : IDCompositionDeviceDebug [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4A, 0xC6, 0xA3, 0xA1, 0x4F, 0x22, 0x81, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionDeviceDebug : IDCompositionDeviceDebug 0x9D, 0x3C, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffect.cs index 3b33e0e..dde18dc 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionEffect : IDCompositionEffect.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8F, 0xB0, 0x81, 0xEC, 0xCB, 0xBF, 0x8D, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionEffect : IDCompositionEffect.Interface 0x79, 0x99, 0xE8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffectGroup.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffectGroup.cs index 9b5a612..5f07438 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffectGroup.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionEffectGroup.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionEffectGroup : IDCompositionEffectGroup [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x74, 0x9A, 0x92, 0xA7, 0xB2, 0xE6, 0xD6, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionEffectGroup : IDCompositionEffectGroup 0x9C, 0xA3, 0x4D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionFilterEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionFilterEffect.cs index a3717e7..63c8841 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionFilterEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionFilterEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionFilterEffect : IDCompositionFilterEffe [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD5, 0x21, 0xC4, 0x30, 0xB2, 0x8C, 0x9F, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionFilterEffect : IDCompositionFilterEffe 0x0D, 0x4A, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionGaussianBlurEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionGaussianBlurEffect.cs index 87fd134..2be7d0e 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionGaussianBlurEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionGaussianBlurEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionGaussianBlurEffect : IDCompositionGaus [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB7, 0xD0, 0xD4, 0x45, 0xD4, 0x1B, 0x4E, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionGaussianBlurEffect : IDCompositionGaus 0x44, 0x30, 0x33 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionHueRotationEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionHueRotationEffect.cs index d0ef49f..b0baa20 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionHueRotationEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionHueRotationEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionHueRotationEffect : IDCompositionHueRo [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x20, 0xF9, 0xB9, 0x6D, 0x70, 0x07, 0x81, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionHueRotationEffect : IDCompositionHueRo 0xF9, 0xD1, 0x67 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionInkTrailDevice.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionInkTrailDevice.cs index 0f0c520..f340284 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionInkTrailDevice.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionInkTrailDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionInkTrailDevice : IDCompositionInkTrail [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEC, 0x7C, 0x0C, 0xDF, 0xEB, 0xCD, 0x4A, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionInkTrailDevice : IDCompositionInkTrail 0x2F, 0x4E, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionLinearTransferEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionLinearTransferEffect.cs index 4b365f4..1e094d4 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionLinearTransferEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionLinearTransferEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionLinearTransferEffect : IDCompositionLi [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0xEE, 0x05, 0x43, 0xA0, 0xC4, 0x88, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionLinearTransferEffect : IDCompositionLi 0x01, 0x76, 0x83 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform.cs index a4d3fab..2b9d822 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionMatrixTransform : IDCompositionMatrixT [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x07, 0xFF, 0xCD, 0x16, 0x03, 0xC5, 0x9C, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionMatrixTransform : IDCompositionMatrixT 0xAF, 0x1F, 0xA6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform3D.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform3D.cs index 8f16c16..4ef7b0a 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform3D.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionMatrixTransform3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionMatrixTransform3D : IDCompositionMatri [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF0, 0x63, 0x33, 0x4B, 0x3B, 0x64, 0xB7, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionMatrixTransform3D : IDCompositionMatri 0x34, 0x46, 0x7C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRectangleClip.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRectangleClip.cs index 6ab4da4..d32bb51 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRectangleClip.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRectangleClip.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionRectangleClip : IDCompositionRectangle [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7D, 0xAD, 0x42, 0x98, 0xCF, 0xD9, 0x08, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionRectangleClip : IDCompositionRectangle 0xA5, 0xE7, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform.cs index 445e954..18be5f9 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionRotateTransform : IDCompositionRotateT [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3C, 0xD8, 0x1E, 0x64, 0x96, 0xAE, 0xC5, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionRotateTransform : IDCompositionRotateT 0xC5, 0xC6, 0xD5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform3D.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform3D.cs index 7b9f914..f89fd8b 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform3D.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionRotateTransform3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionRotateTransform3D : IDCompositionRotat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3F, 0xB2, 0xF5, 0xD8, 0x29, 0xD4, 0x91, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionRotateTransform3D : IDCompositionRotat 0xD7, 0x5B, 0x18 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSaturationEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSaturationEffect.cs index d3538c6..25ddb81 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSaturationEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSaturationEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionSaturationEffect : IDCompositionSatura [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0xEB, 0x8D, 0xA0, 0x58, 0x32, 0xA4, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionSaturationEffect : IDCompositionSatura 0xFE, 0x93, 0xB1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform.cs index 6a21e46..49ab7c4 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionScaleTransform : IDCompositionScaleTra [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x14, 0xE9, 0xFD, 0x71, 0xEF, 0x40, 0xEF, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionScaleTransform : IDCompositionScaleTra 0xC3, 0x39, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform3D.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform3D.cs index c195d0c..997eb96 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform3D.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionScaleTransform3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionScaleTransform3D : IDCompositionScaleT [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAD, 0x9E, 0x9E, 0x2A, 0x4B, 0x36, 0x15, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionScaleTransform3D : IDCompositionScaleT 0x78, 0xB3, 0x89 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionShadowEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionShadowEffect.cs index 2b296b2..c6f836c 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionShadowEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionShadowEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionShadowEffect : IDCompositionShadowEffe [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC0, 0x8A, 0xD1, 0x4A, 0xD2, 0xCF, 0x2F, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionShadowEffect : IDCompositionShadowEffe 0xDB, 0x68, 0x79 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSkewTransform.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSkewTransform.cs index dbadc5b..1757e39 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSkewTransform.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSkewTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionSkewTransform : IDCompositionSkewTrans [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x35, 0xA7, 0x7A, 0xE5, 0xDB, 0xDC, 0x72, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionSkewTransform : IDCompositionSkewTrans 0x88, 0x89, 0xEE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurface.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurface.cs index 88203b7..0eab7a0 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurface.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurface.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionSurface : IDCompositionSurface.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x53, 0x49, 0x8A, 0xBB, 0x99, 0x2C, 0x5A, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionSurface : IDCompositionSurface.Interfa 0x7F, 0xA3, 0xAC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurfaceFactory.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurfaceFactory.cs index f539de8..c1b6237 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurfaceFactory.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionSurfaceFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionSurfaceFactory : IDCompositionSurfaceF [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x12, 0xBC, 0x34, 0xE3, 0x37, 0x39, 0x02, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionSurfaceFactory : IDCompositionSurfaceF 0x30, 0xD2, 0xC8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTableTransferEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTableTransferEffect.cs index ca74c6a..6dcb5c2 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTableTransferEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTableTransferEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTableTransferEffect : IDCompositionTab [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE2, 0x82, 0x7E, 0x9B, 0xC5, 0x69, 0xB4, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTableTransferEffect : IDCompositionTab 0x51, 0x32, 0xCD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTarget.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTarget.cs index c696bdd..e7e1f34 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTarget.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTarget : IDCompositionTarget.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4C, 0xD0, 0xCD, 0xEA, 0x7E, 0x11, 0x17, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTarget : IDCompositionTarget.Interface 0x0E, 0x3D, 0x89 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTexture.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTexture.cs index af88e4d..46bafe4 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTexture.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTexture.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTexture : IDCompositionTexture.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0xB1, 0x9B, 0x92, 0x5F, 0x72, 0x3B, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTexture : IDCompositionTexture.Interfa 0xA8, 0x35, 0xF2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform.cs index 9316550..07e8791 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTransform : IDCompositionTransform.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA7, 0xFA, 0x55, 0xFD, 0xE0, 0x37, 0x20, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTransform : IDCompositionTransform.Int 0xC3, 0x3F, 0x55 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform3D.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform3D.cs index d91ae4b..1e0a2a7 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform3D.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTransform3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTransform3D : IDCompositionTransform3D [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x22, 0x57, 0x18, 0x71, 0x6B, 0x24, 0xF2, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTransform3D : IDCompositionTransform3D 0xF4, 0xBF, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform.cs index 32feccb..5653d52 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTranslateTransform : IDCompositionTran [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x22, 0x11, 0x79, 0x06, 0xF0, 0xC6, 0x7D, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTranslateTransform : IDCompositionTran 0x7F, 0x59, 0x54 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform3D.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform3D.cs index c271d4a..841bfc6 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform3D.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTranslateTransform3D.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTranslateTransform3D : IDCompositionTr [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4B, 0x6D, 0x63, 0x91, 0xA1, 0x9B, 0x32, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTranslateTransform3D : IDCompositionTr 0x94, 0xD7, 0x88 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTurbulenceEffect.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTurbulenceEffect.cs index 953e89d..24a1dd8 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTurbulenceEffect.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionTurbulenceEffect.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionTurbulenceEffect : IDCompositionTurbul [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x5B, 0xA5, 0xA6, 0x9C, 0xC0, 0xF3, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionTurbulenceEffect : IDCompositionTurbul 0xC8, 0x97, 0x15 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVirtualSurface.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVirtualSurface.cs index fcbb6a3..7e544ad 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVirtualSurface.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVirtualSurface.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionVirtualSurface : IDCompositionVirtualS [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x51, 0x1C, 0x47, 0xAE, 0x53, 0x5F, 0x24, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionVirtualSurface : IDCompositionVirtualS 0x30, 0xB3, 0xF0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual.cs index 8787737..06d746e 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionVisual : IDCompositionVisual.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9D, 0x05, 0x93, 0x4D, 0x7B, 0x09, 0x51, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionVisual : IDCompositionVisual.Interface 0x16, 0xE2, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual2.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual2.cs index b1ae7ee..8283432 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual2.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionVisual2 : IDCompositionVisual2.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x39, 0x16, 0xDE, 0xE8, 0x31, 0x43, 0x26, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionVisual2 : IDCompositionVisual2.Interfa 0x34, 0x7A, 0x85 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual3.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual3.cs index 69f31e5..28053b2 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual3.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisual3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionVisual3 : IDCompositionVisual3.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0xF4, 0x75, 0x27, 0xC1, 0xB6, 0x15, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionVisual3 : IDCompositionVisual3.Interfa 0xA4, 0x97, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisualDebug.cs b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisualDebug.cs index 038d0cd..6e01b35 100644 --- a/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisualDebug.cs +++ b/src/Vortice.Win32.Graphics.DirectComposition/Generated/IDCompositionVisualDebug.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDCompositionVisualDebug : IDCompositionVisualDebug [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x08, 0xB8, 0xD2, 0xFE, 0xB4, 0x5E, 0xA0, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDCompositionVisualDebug : IDCompositionVisualDebug 0x80, 0xF9, 0x1B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/Graphics.DirectWrite.Structs.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/Graphics.DirectWrite.Structs.cs index 1aecbb8..29b0a2d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/Graphics.DirectWrite.Structs.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/Graphics.DirectWrite.Structs.cs @@ -1062,6 +1062,31 @@ public partial struct PaintElement /// public PaintColor color; } + public partial struct PAINT_SWEEP_GRADIENT + { + /// + public uint extendMode; + + /// + public uint gradientStopCount; + + /// + public float centerX; + + /// + public float centerY; + + /// + public float startAngle; + + /// + public float endAngle; + } + public partial struct PAINT_LAYERS + { + /// + public uint childCount; + } public partial struct PAINT_COLOR_GLYPH { /// @@ -1096,30 +1121,5 @@ public partial struct PaintElement /// public float y2; } - public partial struct PAINT_LAYERS - { - /// - public uint childCount; - } - public partial struct PAINT_SWEEP_GRADIENT - { - /// - public uint extendMode; - - /// - public uint gradientStopCount; - - /// - public float centerX; - - /// - public float centerY; - - /// - public float startAngle; - - /// - public float endAngle; - } } } diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteAsyncResult.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteAsyncResult.cs index a805b72..a307213 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteAsyncResult.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteAsyncResult.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteAsyncResult : IDWriteAsyncResult.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFD, 0xF8, 0x25, 0xCE, 0x3B, 0x86, 0x13, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteAsyncResult : IDWriteAsyncResult.Interface, 0xC7, 0x3F, 0xE2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget.cs index 0889ff3..bc6e4e5 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget : IDWriteBitmapRenderTarg [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA3, 0x32, 0x5A, 0x5E, 0xFF, 0x8D, 0x73, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget : IDWriteBitmapRenderTarg 0xB7, 0x72, 0x67 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget1.cs index df5a8a3..afbbadc 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget1 : IDWriteBitmapRenderTar [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x98, 0x82, 0x1E, 0x79, 0xF3, 0x3E, 0x30, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget1 : IDWriteBitmapRenderTar 0xC4, 0x20, 0x64 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget2.cs index 205e133..0dfa299 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget2 : IDWriteBitmapRenderTar [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x42, 0xA7, 0x53, 0xC5, 0x01, 0xFC, 0xDA, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget2 : IDWriteBitmapRenderTar 0x6C, 0x39, 0x95 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget3.cs index f5d0cd9..69761f6 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteBitmapRenderTarget3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget3 : IDWriteBitmapRenderTar [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0x37, 0xEC, 0xAE, 0x37, 0xC3, 0xF1, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteBitmapRenderTarget3 : IDWriteBitmapRenderTar 0x67, 0xB2, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator.cs index dac9dfd..d7c1cbb 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteColorGlyphRunEnumerator : IDWriteColorGlyphR [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x17, 0xBE, 0x1F, 0xD3, 0x57, 0xF1, 0xA2, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteColorGlyphRunEnumerator : IDWriteColorGlyphR 0x05, 0x60, 0xE8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator1.cs index 7e96bb5..f1596bb 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteColorGlyphRunEnumerator1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteColorGlyphRunEnumerator1 : IDWriteColorGlyph [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x86, 0x5F, 0x7C, 0xA1, 0xC7, 0x05, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteColorGlyphRunEnumerator1 : IDWriteColorGlyph 0xFE, 0x5A, 0x35 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory.cs index d504a19..7b22c35 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory : IDWriteFactory.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5A, 0xEE, 0x59, 0xB8, 0x38, 0xD8, 0x5B, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory : IDWriteFactory.Interface, INativeG 0x93, 0xDB, 0x48 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory1.cs index 251e0ee..6323cd1 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory1 : IDWriteFactory1.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x99, 0x2F, 0x57, 0x30, 0xC6, 0xDA, 0xDB, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory1 : IDWriteFactory1.Interface, INativ 0x7E, 0x60, 0x6A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory2.cs index 83bd668..7cdee66 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory2 : IDWriteFactory2.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x60, 0xFC, 0x39, 0x04, 0x44, 0xCA, 0x94, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory2 : IDWriteFactory2.Interface, INativ 0xB7, 0x32, 0xEC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory3.cs index ea95cb1..203e1f6 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory3 : IDWriteFactory3.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x41, 0x1B, 0x9A, 0xBB, 0xD3, 0x6A, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory3 : IDWriteFactory3.Interface, INativ 0x6A, 0x3B, 0x65 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory4.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory4.cs index db1331e..1b48f3a 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory4.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory4 : IDWriteFactory4.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD3, 0x5B, 0x0B, 0x4B, 0x97, 0x07, 0x49, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory4 : IDWriteFactory4.Interface, INativ 0xC5, 0x38, 0x56 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory5.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory5.cs index 3c2d794..4e1ca93 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory5.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory5.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory5 : IDWriteFactory5.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9A, 0xB9, 0x8D, 0x95, 0x2A, 0xBE, 0x09, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory5 : IDWriteFactory5.Interface, INativ 0x03, 0xD1, 0xD3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory6.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory6.cs index ecf8c4e..5d930b3 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory6.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory6.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory6 : IDWriteFactory6.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x80, 0x4D, 0x74, 0xF3, 0xF7, 0x21, 0xEB, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory6 : IDWriteFactory6.Interface, INativ 0x2F, 0xC2, 0x23 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory7.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory7.cs index 693610e..6e35a7e 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory7.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory7.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory7 : IDWriteFactory7.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB3, 0xE0, 0xD0, 0x35, 0x76, 0x90, 0x2E, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory7 : IDWriteFactory7.Interface, INativ 0x8A, 0x06, 0xB4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory8.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory8.cs index d5e51c4..6c7210c 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory8.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFactory8.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFactory8 : IDWriteFactory8.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB5, 0x7F, 0x0A, 0xEE, 0xF4, 0xDE, 0x23, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFactory8 : IDWriteFactory8.Interface, INativ 0x87, 0x83, 0x98 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont.cs index 0d5b237..a3a3b44 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFont : IDWriteFont.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x96, 0x66, 0xD1, 0xAC, 0x14, 0x8C, 0x5D, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFont : IDWriteFont.Interface, INativeGuid 0xD3, 0x27, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont1.cs index efb7acc..6ee0743 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFont1 : IDWriteFont1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x96, 0x66, 0xD1, 0xAC, 0x14, 0x8C, 0x5D, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFont1 : IDWriteFont1.Interface, INativeGuid 0xD3, 0x27, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont2.cs index 9edf48f..152a2a7 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFont2 : IDWriteFont2.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0x8E, 0x74, 0x29, 0x9C, 0x8C, 0x6A, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFont2 : IDWriteFont2.Interface, INativeGuid 0x53, 0x89, 0x44 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont3.cs index fd230c9..78c6044 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFont3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFont3 : IDWriteFont3.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD6, 0x8E, 0x74, 0x29, 0x9C, 0x8C, 0x6A, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFont3 : IDWriteFont3.Interface, INativeGuid 0x53, 0x89, 0x44 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection.cs index c6c4c36..36c91c5 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontCollection : IDWriteFontCollection.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0xEE, 0x4C, 0xA8, 0xEA, 0x3E, 0xEE, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontCollection : IDWriteFontCollection.Inter 0x2A, 0x0F, 0xCC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection1.cs index 7d7d80e..4837d3a 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontCollection1 : IDWriteFontCollection1.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x41, 0x51, 0x58, 0x53, 0xF8, 0xD9, 0x95, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontCollection1 : IDWriteFontCollection1.Int 0xBD, 0x11, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection2.cs index d69e067..0d4e7fd 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontCollection2 : IDWriteFontCollection2.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC6, 0x39, 0x40, 0x51, 0x17, 0x46, 0x64, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontCollection2 : IDWriteFontCollection2.Int 0xE5, 0x06, 0xE0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection3.cs index 20587ee..876ef5e 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollection3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontCollection3 : IDWriteFontCollection3.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0x55, 0xD0, 0xA4, 0xE3, 0xF9, 0x25, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontCollection3 : IDWriteFontCollection3.Int 0x3A, 0xF8, 0xE9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollectionLoader.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollectionLoader.cs index 5fe7bde..3208de0 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollectionLoader.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontCollectionLoader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontCollectionLoader : IDWriteFontCollection [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE4, 0x20, 0xA9, 0xCC, 0xF0, 0x52, 0x2B, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontCollectionLoader : IDWriteFontCollection 0xE0, 0xA4, 0x68 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadListener.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadListener.cs index 339fd74..631a879 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadListener.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadListener.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontDownloadListener : IDWriteFontDownloadLi [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB9, 0xE5, 0x6F, 0xB0, 0xEC, 0x43, 0x93, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontDownloadListener : IDWriteFontDownloadLi 0x72, 0xFD, 0xA7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadQueue.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadQueue.cs index feb2513..0798669 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadQueue.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontDownloadQueue.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontDownloadQueue : IDWriteFontDownloadQueue [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x52, 0x60, 0x1E, 0xB7, 0xEA, 0x5A, 0xA3, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontDownloadQueue : IDWriteFontDownloadQueue 0x1F, 0x7E, 0x91 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace.cs index e19213e..4c985de 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace : IDWriteFontFace.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4D, 0x80, 0x49, 0x5F, 0x24, 0x70, 0x43, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace : IDWriteFontFace.Interface, INativ 0xF5, 0x38, 0x49 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace1.cs index df39007..b6ef249 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace1 : IDWriteFontFace1.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB4, 0xFD, 0x1E, 0xA7, 0xDB, 0x9F, 0x38, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace1 : IDWriteFontFace1.Interface, INat 0x8C, 0x3D, 0xAF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace2.cs index 133fdab..24a10f6 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace2 : IDWriteFontFace2.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFF, 0x68, 0xB7, 0xD8, 0xBC, 0x64, 0x66, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace2 : IDWriteFontFace2.Interface, INat 0xF6, 0x93, 0xF7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace3.cs index 88ad1fa..54830d4 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace3 : IDWriteFontFace3.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x98, 0x75, 0x7D, 0xD3, 0xBE, 0x09, 0x22, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace3 : IDWriteFontFace3.Interface, INat 0x1C, 0xC1, 0xF2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace4.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace4.cs index 15bbebe..afce060 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace4.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace4 : IDWriteFontFace4.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x04, 0xA9, 0xF2, 0x27, 0xB8, 0x4E, 0x1D, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace4 : IDWriteFontFace4.Interface, INat 0x3E, 0x3E, 0x2F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace5.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace5.cs index 2b18f1e..0786d7d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace5.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace5.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace5 : IDWriteFontFace5.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA5, 0xF3, 0xEF, 0x98, 0x67, 0xB6, 0x9A, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace5 : IDWriteFontFace5.Interface, INat 0x9F, 0xDC, 0x29 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace6.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace6.cs index dc9bae5..9ad5655 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace6.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace6.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace6 : IDWriteFontFace6.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1B, 0xFE, 0xB1, 0xC4, 0x84, 0x6E, 0xD5, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace6 : IDWriteFontFace6.Interface, INat 0x1B, 0x06, 0xAD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace7.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace7.cs index 70299c8..cb3abac 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace7.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFace7.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFace7 : IDWriteFontFace7.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0xB8, 0x45, 0x39, 0x95, 0xBC, 0xF7, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFace7 : IDWriteFontFace7.Interface, INat 0xC7, 0xE1, 0x3B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference.cs index a5377d8..4c53f48 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFaceReference : IDWriteFontFaceReference [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0xA7, 0x7F, 0x5E, 0xE3, 0xDD, 0x4C, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFaceReference : IDWriteFontFaceReference 0xED, 0x58, 0xCD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference1.cs index af9ea69..2013502 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFaceReference1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFaceReference1 : IDWriteFontFaceReferenc [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x77, 0xFE, 0x81, 0xC0, 0xD1, 0x2F, 0xAC, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFaceReference1 : IDWriteFontFaceReferenc 0x4B, 0xA6, 0x1A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback.cs index 7804c53..53bea30 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFallback : IDWriteFontFallback.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF9, 0x08, 0xA0, 0xEF, 0xA1, 0xF7, 0xBF, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFallback : IDWriteFontFallback.Interface 0x3C, 0xC0, 0xFF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback1.cs index b9826e2..0b42a26 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallback1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFallback1 : IDWriteFontFallback1.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9D, 0x59, 0x97, 0x23, 0x0D, 0xDD, 0x81, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFallback1 : IDWriteFontFallback1.Interfa 0xAA, 0xDE, 0x77 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallbackBuilder.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallbackBuilder.cs index c4c3067..095afdd 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallbackBuilder.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFallbackBuilder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFallbackBuilder : IDWriteFontFallbackBui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x06, 0x2D, 0x88, 0xFD, 0xBA, 0x8A, 0xB8, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFallbackBuilder : IDWriteFontFallbackBui 0x3E, 0x14, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily.cs index 5cd2158..f606b52 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFamily : IDWriteFontFamily.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEF, 0xD8, 0x20, 0xDA, 0x2A, 0x81, 0x43, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFamily : IDWriteFontFamily.Interface, IN 0xBD, 0x7A, 0xDD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily1.cs index caf6dab..af11429 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFamily1 : IDWriteFontFamily1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEF, 0xD8, 0x20, 0xDA, 0x2A, 0x81, 0x43, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFamily1 : IDWriteFontFamily1.Interface, 0xBD, 0x7A, 0xDF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily2.cs index 5472673..65f4fa0 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFamily2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFamily2 : IDWriteFontFamily2.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x77, 0x9E, 0xD4, 0x3E, 0x98, 0xA3, 0x61, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFamily2 : IDWriteFontFamily2.Interface, 0x13, 0x1E, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFile.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFile.cs index 71b31cd..5598a32 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFile.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFile.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFile : IDWriteFontFile.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6A, 0x88, 0x9D, 0x73, 0xF5, 0xCE, 0xDC, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFile : IDWriteFontFile.Interface, INativ 0xBE, 0xBB, 0xB0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileEnumerator.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileEnumerator.cs index 4171dd2..1dec6a8 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileEnumerator.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileEnumerator.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFileEnumerator : IDWriteFontFileEnumerat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x49, 0x50, 0x75, 0x72, 0xF7, 0x5F, 0x5D, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFileEnumerator : IDWriteFontFileEnumerat 0xFA, 0x6C, 0x7C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileLoader.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileLoader.cs index f8e99b3..b48ef66 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileLoader.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileLoader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFileLoader : IDWriteFontFileLoader.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4E, 0xAD, 0x7C, 0x72, 0xAF, 0xD6, 0x9E, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFileLoader : IDWriteFontFileLoader.Inter 0x1C, 0xAA, 0x49 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileStream.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileStream.cs index 6bc120c..984dd79 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileStream.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontFileStream.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontFileStream : IDWriteFontFileStream.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFE, 0x65, 0x48, 0x6D, 0xB8, 0x0A, 0x91, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontFileStream : IDWriteFontFileStream.Inter 0x34, 0xA3, 0xE0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList.cs index c1d1d8e..cad44b8 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontList : IDWriteFontList.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x38, 0x84, 0x0D, 0x1A, 0x97, 0x1D, 0xC1, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontList : IDWriteFontList.Interface, INativ 0xED, 0x6A, 0xCB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList1.cs index 2cff3a8..253c93d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontList1 : IDWriteFontList1.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEF, 0xD8, 0x20, 0xDA, 0x2A, 0x81, 0x43, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontList1 : IDWriteFontList1.Interface, INat 0xBD, 0x7A, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList2.cs index 3893570..f09f43b 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontList2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontList2 : IDWriteFontList2.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x34, 0x3A, 0x76, 0xC0, 0xAF, 0x77, 0x5A, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontList2 : IDWriteFontList2.Interface, INat 0x0A, 0x5B, 0xF5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontResource.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontResource.cs index 3475db0..106b2a6 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontResource.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontResource.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontResource : IDWriteFontResource.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x76, 0x3A, 0x80, 0x1F, 0x71, 0x68, 0xE8, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontResource : IDWriteFontResource.Interface 0x1C, 0x50, 0xF2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet.cs index 31aface..cdb20fc 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSet : IDWriteFontSet.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x41, 0x51, 0x58, 0x53, 0xF8, 0xD9, 0x95, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSet : IDWriteFontSet.Interface, INativeG 0xBD, 0x11, 0x6B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet1.cs index 1ff4c2f..3796d63 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSet1 : IDWriteFontSet1.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0xDA, 0x9F, 0x7E, 0x92, 0x6C, 0x53, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSet1 : IDWriteFontSet1.Interface, INativ 0x0D, 0xB4, 0xD3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet2.cs index 1c7f366..57988a8 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSet2 : IDWriteFontSet2.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0xAD, 0x7E, 0xDC, 0x4C, 0xE5, 0xAF, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSet2 : IDWriteFontSet2.Interface, INativ 0xBA, 0x3F, 0x7F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet3.cs index 9aa5db9..02db8f8 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSet3 : IDWriteFontSet3.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF2, 0x3E, 0x07, 0x7C, 0xF4, 0xA7, 0x45, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSet3 : IDWriteFontSet3.Interface, INativ 0x64, 0x0F, 0x90 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet4.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet4.cs index f453124..265c48f 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet4.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSet4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSet4 : IDWriteFontSet4.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFC, 0x75, 0xC1, 0xEE, 0xA9, 0xBE, 0x86, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSet4 : IDWriteFontSet4.Interface, INativ 0xDF, 0x0C, 0x82 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder.cs index 0c430f1..37fc7a4 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSetBuilder : IDWriteFontSetBuilder.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFE, 0x2A, 0x64, 0x2F, 0x68, 0x9C, 0x40, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSetBuilder : IDWriteFontSetBuilder.Inter 0xAF, 0xCB, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder1.cs index 09ae065..7bac83d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSetBuilder1 : IDWriteFontSetBuilder1.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5F, 0x71, 0xF7, 0x3F, 0xDC, 0x3C, 0xC6, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSetBuilder1 : IDWriteFontSetBuilder1.Int 0xDC, 0xCA, 0xFD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder2.cs index 050725b..0e41d9b 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteFontSetBuilder2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteFontSetBuilder2 : IDWriteFontSetBuilder2.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x12, 0xA6, 0x5B, 0xEE, 0x31, 0xB1, 0x3C, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteFontSetBuilder2 : IDWriteFontSetBuilder2.Int 0x40, 0x1E, 0x45 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop.cs index fd032e9..0cedd89 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteGdiInterop : IDWriteGdiInterop.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x91, 0x94, 0xDD, 0x1E, 0x53, 0x98, 0x99, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteGdiInterop : IDWriteGdiInterop.Interface, IN 0x3B, 0x6F, 0x3A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop1.cs index 5dfd1b4..80a848b 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGdiInterop1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteGdiInterop1 : IDWriteGdiInterop1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x70, 0xBE, 0x56, 0x45, 0xBD, 0x3A, 0x70, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteGdiInterop1 : IDWriteGdiInterop1.Interface, 0xA6, 0xF5, 0x15 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGlyphRunAnalysis.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGlyphRunAnalysis.cs index 9e86d7a..449163d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGlyphRunAnalysis.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteGlyphRunAnalysis.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteGlyphRunAnalysis : IDWriteGlyphRunAnalysis.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF7, 0xDB, 0x97, 0x7D, 0x85, 0xE0, 0xD4, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteGlyphRunAnalysis : IDWriteGlyphRunAnalysis.I 0xDE, 0xD1, 0x18 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInMemoryFontFileLoader.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInMemoryFontFileLoader.cs index fb8b452..b338543 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInMemoryFontFileLoader.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInMemoryFontFileLoader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteInMemoryFontFileLoader : IDWriteInMemoryFont [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x47, 0x2F, 0x10, 0xDC, 0x2D, 0xA1, 0x1C, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteInMemoryFontFileLoader : IDWriteInMemoryFont 0x33, 0x04, 0x3F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInlineObject.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInlineObject.cs index 870193d..1982d76 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInlineObject.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteInlineObject.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteInlineObject : IDWriteInlineObject.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE3, 0xFD, 0x39, 0x83, 0x6F, 0x10, 0xAB, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteInlineObject : IDWriteInlineObject.Interface 0xEB, 0x10, 0xB3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalFontFileLoader.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalFontFileLoader.cs index 37f8f46..59dfedf 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalFontFileLoader.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalFontFileLoader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteLocalFontFileLoader : IDWriteLocalFontFileLo [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEC, 0xF3, 0xD9, 0xB2, 0xFE, 0xC9, 0x11, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteLocalFontFileLoader : IDWriteLocalFontFileLo 0xF7, 0xC0, 0xA2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalizedStrings.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalizedStrings.cs index 1c36f13..60a4e40 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalizedStrings.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteLocalizedStrings.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteLocalizedStrings : IDWriteLocalizedStrings.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x09, 0x62, 0x25, 0x08, 0x9A, 0x09, 0x34, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteLocalizedStrings : IDWriteLocalizedStrings.I 0x0E, 0x77, 0x71 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteNumberSubstitution.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteNumberSubstitution.cs index 4ee5f44..99b792c 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteNumberSubstitution.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteNumberSubstitution.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteNumberSubstitution : IDWriteNumberSubstituti [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC9, 0x5C, 0x88, 0x14, 0xB0, 0xBA, 0x90, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteNumberSubstitution : IDWriteNumberSubstituti 0x2C, 0xD0, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePaintReader.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePaintReader.cs index 70dc868..6ee9f77 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePaintReader.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePaintReader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWritePaintReader : IDWritePaintReader.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x12, 0xE9, 0x28, 0x81, 0x97, 0x3B, 0xA5, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWritePaintReader : IDWritePaintReader.Interface, 0xA8, 0x6E, 0x54 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePixelSnapping.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePixelSnapping.cs index 31b03f5..ff1c25c 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePixelSnapping.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWritePixelSnapping.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWritePixelSnapping : IDWritePixelSnapping.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0xA2, 0xF3, 0xEA, 0xF4, 0xEC, 0x24, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWritePixelSnapping : IDWritePixelSnapping.Interfa 0x42, 0x02, 0x4B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileLoader.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileLoader.cs index a123b5f..e692e7a 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileLoader.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileLoader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteRemoteFontFileLoader : IDWriteRemoteFontFile [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x83, 0x8C, 0x64, 0x68, 0xDE, 0x6E, 0xC0, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteRemoteFontFileLoader : IDWriteRemoteFontFile 0x88, 0x7F, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileStream.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileStream.cs index ecdba68..bcb447a 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileStream.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRemoteFontFileStream.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteRemoteFontFileStream : IDWriteRemoteFontFile [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7A, 0x75, 0xB3, 0x4D, 0x72, 0x2C, 0xD9, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteRemoteFontFileStream : IDWriteRemoteFontFile 0x1A, 0xFF, 0x9C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams.cs index 2db57ab..154802d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteRenderingParams : IDWriteRenderingParams.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3A, 0xA5, 0x0D, 0x2F, 0xDD, 0x2A, 0xCD, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteRenderingParams : IDWriteRenderingParams.Int 0x68, 0x8E, 0x75 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams1.cs index 26bb87d..a377a32 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteRenderingParams1 : IDWriteRenderingParams1.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF4, 0x3C, 0x41, 0x94, 0xFC, 0xA6, 0x48, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteRenderingParams1 : IDWriteRenderingParams1.I 0x8F, 0xCA, 0xD3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams2.cs index e713116..e97e1ee 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteRenderingParams2 : IDWriteRenderingParams2.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0x11, 0xD7, 0xF9, 0x77, 0x97, 0xAE, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteRenderingParams2 : IDWriteRenderingParams2.I 0xBF, 0x09, 0x48 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams3.cs index f4fc248..09279a7 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteRenderingParams3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteRenderingParams3 : IDWriteRenderingParams3.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0x4B, 0x92, 0xB7, 0x1B, 0x39, 0x2A, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteRenderingParams3 : IDWriteRenderingParams3.I 0xD8, 0x67, 0xDC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteStringList.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteStringList.cs index fd4bb83..ac48620 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteStringList.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteStringList.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteStringList : IDWriteStringList.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x40, 0x31, 0xEE, 0xCF, 0x57, 0x11, 0xCA, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteStringList : IDWriteStringList.Interface, IN 0x3F, 0x2D, 0x0E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink.cs index eb7900f..bbf177d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalysisSink : IDWriteTextAnalysisSink.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x44, 0xCD, 0x10, 0x58, 0xA0, 0x0C, 0x01, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalysisSink : IDWriteTextAnalysisSink.I 0x2A, 0xE4, 0xF6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink1.cs index aa857b2..2f803a9 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSink1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalysisSink1 : IDWriteTextAnalysisSink1 [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA0, 0x41, 0xD9, 0xB0, 0xE7, 0x85, 0x8B, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalysisSink1 : IDWriteTextAnalysisSink1 0x34, 0x48, 0x2A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource.cs index 6a407f7..f814542 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalysisSource : IDWriteTextAnalysisSour [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x58, 0x1A, 0x8E, 0x68, 0x94, 0x50, 0xC8, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalysisSource : IDWriteTextAnalysisSour 0x0A, 0xE9, 0x2B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource1.cs index e107fa7..5455e4c 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalysisSource1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalysisSource1 : IDWriteTextAnalysisSou [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD8, 0xFA, 0x9C, 0x63, 0xB4, 0x0F, 0x21, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalysisSource1 : IDWriteTextAnalysisSou 0x12, 0x00, 0x09 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer.cs index cefe687..d3b76ee 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalyzer : IDWriteTextAnalyzer.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3E, 0x16, 0xE6, 0xB7, 0x46, 0x7F, 0xB4, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalyzer : IDWriteTextAnalyzer.Interface 0x9C, 0x36, 0x5D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer1.cs index 623bd82..6a47fa3 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalyzer1 : IDWriteTextAnalyzer1.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x00, 0xD8, 0xDA, 0x80, 0x1F, 0xE2, 0x83, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalyzer1 : IDWriteTextAnalyzer1.Interfa 0x00, 0xDB, 0x7C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer2.cs index 43f82da..cf37c1c 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextAnalyzer2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextAnalyzer2 : IDWriteTextAnalyzer2.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF3, 0x9F, 0x3A, 0x55, 0x93, 0x56, 0xF7, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextAnalyzer2 : IDWriteTextAnalyzer2.Interfa 0x7F, 0x2E, 0xB9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat.cs index e8630eb..3da158d 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextFormat : IDWriteTextFormat.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x18, 0x68, 0x90, 0x9C, 0xD7, 0x31, 0xD3, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextFormat : IDWriteTextFormat.Interface, IN 0x5D, 0xB5, 0x5A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat1.cs index 2b0e526..b4bcc43 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextFormat1 : IDWriteTextFormat1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x49, 0x4B, 0x17, 0x5F, 0x8B, 0x0D, 0xFB, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextFormat1 : IDWriteTextFormat1.Interface, 0xD0, 0x6C, 0x67 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat2.cs index 852ee47..f438938 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextFormat2 : IDWriteTextFormat2.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDD, 0x0E, 0x7E, 0xF6, 0x3D, 0x9E, 0xCC, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextFormat2 : IDWriteTextFormat2.Interface, 0x3D, 0xFE, 0x70 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat3.cs index 1a04109..7334159 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextFormat3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextFormat3 : IDWriteTextFormat3.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x41, 0x56, 0x3B, 0x6D, 0x50, 0xE5, 0x0D, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextFormat3 : IDWriteTextFormat3.Interface, 0xA9, 0x34, 0x27 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout.cs index dd85794..349e6d5 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextLayout : IDWriteTextLayout.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0x70, 0x73, 0x53, 0x14, 0x6D, 0x0B, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextLayout : IDWriteTextLayout.Interface, IN 0xB7, 0x09, 0x61 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout1.cs index f04f124..745a072 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextLayout1 : IDWriteTextLayout1.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x22, 0xD8, 0x64, 0x90, 0xA7, 0x80, 0x5C, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextLayout1 : IDWriteTextLayout1.Interface, 0x8B, 0x8F, 0xEB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout2.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout2.cs index ec30518..7686212 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout2.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextLayout2 : IDWriteTextLayout2.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8F, 0xC1, 0x93, 0x10, 0x5E, 0x8D, 0xF0, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextLayout2 : IDWriteTextLayout2.Interface, 0x1B, 0x52, 0x5E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout3.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout3.cs index 7ef1bcc..acd9cee 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout3.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextLayout3 : IDWriteTextLayout3.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x52, 0xCD, 0xDD, 0x07, 0x0E, 0x02, 0xE8, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextLayout3 : IDWriteTextLayout3.Interface, 0x83, 0xF9, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout4.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout4.cs index d785ce0..fb1b6e5 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout4.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextLayout4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextLayout4 : IDWriteTextLayout4.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x42, 0xBF, 0xA9, 0x05, 0x3F, 0x22, 0x41, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextLayout4 : IDWriteTextLayout4.Interface, 0x5F, 0x55, 0xE9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer.cs index 490afdc..fa25559 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextRenderer : IDWriteTextRenderer.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x35, 0x81, 0x8A, 0xEF, 0xC6, 0x5C, 0xFE, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextRenderer : IDWriteTextRenderer.Interface 0x4E, 0xB8, 0x19 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer1.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer1.cs index cbdae58..d76432b 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer1.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTextRenderer1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTextRenderer1 : IDWriteTextRenderer1.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x34, 0xE9, 0xE0, 0xD3, 0xA0, 0x22, 0x7E, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTextRenderer1 : IDWriteTextRenderer1.Interfa 0xB5, 0x9D, 0xB1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTypography.cs b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTypography.cs index f72b0dc..8ea4dde 100644 --- a/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTypography.cs +++ b/src/Vortice.Win32.Graphics.DirectWrite/Generated/IDWriteTypography.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDWriteTypography : IDWriteTypography.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2B, 0x11, 0xF1, 0x55, 0xC2, 0x1D, 0x3C, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDWriteTypography : IDWriteTypography.Interface, IN 0xED, 0x85, 0xB6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/Graphics.Dxgi.Apis.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/Graphics.Dxgi.Apis.cs index 6073bb0..748123a 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/Graphics.Dxgi.Apis.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/Graphics.Dxgi.Apis.cs @@ -20,7 +20,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x83, 0xE2, 0x8A, 0xE4, 0x80, 0xDA, 0x0B, 0x49, @@ -32,7 +32,7 @@ public static partial class Apis 0xCF, 0xDA, 0x08 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -44,7 +44,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFC, 0xD7, 0xCD, 0x35, 0xB2, 0x13, 0x1D, 0x42, @@ -56,7 +56,7 @@ public static partial class Apis 0x28, 0x7D, 0x64 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -68,7 +68,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0xDA, 0xCD, 0x25, 0xC6, 0xB1, 0xE1, 0x47, @@ -80,7 +80,7 @@ public static partial class Apis 0x5A, 0x2E, 0x2A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -92,7 +92,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0x6E, 0xCD, 0x06, 0x19, 0x42, 0xBD, 0x4E, @@ -104,7 +104,7 @@ public static partial class Apis 0x36, 0x0C, 0x62 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -181,6 +181,8 @@ public static partial class Apis public static readonly HResult DXGI_ERROR_MPO_UNPINNED = -2005270428; + public static readonly HResult DXGI_ERROR_SETDISPLAYMODE_REQUIRED = -2005270427; + public const Usage DXGI_USAGE_SHADER_INPUT = Usage.ShaderInput; public const Usage DXGI_USAGE_RENDER_TARGET_OUTPUT = Usage.RenderTargetOutput; public const Usage DXGI_USAGE_BACK_BUFFER = Usage.BackBuffer; diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter.cs index 9840e3a..9144dff 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIAdapter : IDXGIAdapter.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE1, 0xE7, 0x11, 0x24, 0xAC, 0x12, 0xCF, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIAdapter : IDXGIAdapter.Interface, INativeGuid 0x53, 0x4D, 0xC0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter1.cs index f768a07..65118ae 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIAdapter1 : IDXGIAdapter1.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x61, 0x8F, 0x03, 0x29, 0x39, 0x38, 0x26, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIAdapter1 : IDXGIAdapter1.Interface, INativeGui 0x01, 0x1A, 0x05 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter2.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter2.cs index d68232b..9780cf9 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter2.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIAdapter2 : IDXGIAdapter2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0A, 0xAE, 0xA1, 0x0A, 0x0E, 0xFA, 0x84, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIAdapter2 : IDXGIAdapter2.Interface, INativeGui 0xE5, 0xAC, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter3.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter3.cs index 18ce714..12099ef 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter3.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIAdapter3 : IDXGIAdapter3.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0x67, 0x59, 0x64, 0x92, 0x13, 0x10, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIAdapter3 : IDXGIAdapter3.Interface, INativeGui 0x3E, 0x93, 0xFD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter4.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter4.cs index 0b45e9b..bd5a0fe 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter4.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIAdapter4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIAdapter4 : IDXGIAdapter4.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD1, 0x99, 0x8D, 0x3C, 0xBF, 0x4F, 0x81, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIAdapter4 : IDXGIAdapter4.Interface, INativeGui 0x7B, 0xD2, 0x4E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug.cs index 3e7cbc1..96343c7 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDebug : IDXGIDebug.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x52, 0x74, 0x9E, 0x11, 0x9E, 0xDE, 0xFE, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDebug : IDXGIDebug.Interface, INativeGuid 0x12, 0xB4, 0x41 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug1.cs index 64a39c4..da5e01c 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDebug1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDebug1 : IDXGIDebug1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0C, 0x5F, 0xA0, 0xC5, 0xF2, 0x16, 0xDF, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDebug1 : IDXGIDebug1.Interface, INativeGuid 0x8A, 0xC5, 0x50 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDecodeSwapChain.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDecodeSwapChain.cs index 7748081..b5b75e9 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDecodeSwapChain.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDecodeSwapChain.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDecodeSwapChain : IDXGIDecodeSwapChain.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6B, 0x06, 0x33, 0x26, 0x14, 0x45, 0x7A, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDecodeSwapChain : IDXGIDecodeSwapChain.Interfa 0x05, 0x9D, 0x18 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice.cs index 4b036b2..ce30a4e 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDevice : IDXGIDevice.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFA, 0x77, 0xEC, 0x54, 0x77, 0x13, 0xE6, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDevice : IDXGIDevice.Interface, INativeGuid 0x44, 0xC8, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice1.cs index b021848..418e8ff 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDevice1 : IDXGIDevice1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0F, 0x97, 0xDB, 0x77, 0x76, 0x62, 0xBA, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDevice1 : IDXGIDevice1.Interface, INativeGuid 0xB4, 0x39, 0x2C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice2.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice2.cs index c9ecb9e..1f2462d 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice2.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDevice2 : IDXGIDevice2.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x17, 0x86, 0x00, 0x05, 0xFD, 0xFB, 0x51, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDevice2 : IDXGIDevice2.Interface, INativeGuid 0xB4, 0xF6, 0xA9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice3.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice3.cs index 3179f54..bd8a452 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice3.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDevice3 : IDXGIDevice3.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6C, 0x89, 0x07, 0x60, 0x44, 0x32, 0xFD, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDevice3 : IDXGIDevice3.Interface, INativeGuid 0xDA, 0x50, 0x23 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice4.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice4.cs index bb0f2e4..afdad18 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice4.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDevice4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDevice4 : IDXGIDevice4.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5F, 0xF9, 0xB4, 0x95, 0xDA, 0xD8, 0xA4, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDevice4 : IDXGIDevice4.Interface, INativeGuid 0x96, 0x8A, 0x10 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDeviceSubObject.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDeviceSubObject.cs index 543c434..552a653 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDeviceSubObject.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDeviceSubObject.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDeviceSubObject : IDXGIDeviceSubObject.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x79, 0x03, 0x3E, 0x3D, 0xDE, 0xF9, 0x58, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDeviceSubObject : IDXGIDeviceSubObject.Interfa 0x92, 0xF1, 0xA6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDisplayControl.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDisplayControl.cs index 8ae2ef7..03c4d8e 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDisplayControl.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIDisplayControl.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIDisplayControl : IDXGIDisplayControl.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1A, 0xBF, 0x9D, 0xEA, 0x8E, 0xC8, 0x86, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIDisplayControl : IDXGIDisplayControl.Interface 0x38, 0xF3, 0x0C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory.cs index 37ac5ac..2daf6fa 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory : IDXGIFactory.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEC, 0x66, 0x71, 0x7B, 0xC7, 0x21, 0xAE, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory : IDXGIFactory.Interface, INativeGuid 0x1A, 0xE3, 0x69 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory1.cs index 68713c0..5761971 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory1 : IDXGIFactory1.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x78, 0xAE, 0x0A, 0x77, 0x6F, 0xF2, 0xBA, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory1 : IDXGIFactory1.Interface, INativeGui 0xD1, 0xB3, 0x87 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory2.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory2.cs index bbce31b..e6ad79a 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory2.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory2 : IDXGIFactory2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1C, 0x3A, 0xC8, 0x50, 0x72, 0xE0, 0x48, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory2 : IDXGIFactory2.Interface, INativeGui 0x36, 0xA6, 0xD0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory3.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory3.cs index fe0cc95..6d0fd50 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory3.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory3 : IDXGIFactory3.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x23, 0x38, 0x48, 0x25, 0x46, 0xCD, 0x7D, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory3 : IDXGIFactory3.Interface, INativeGui 0xB8, 0x37, 0xBD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory4.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory4.cs index 503fa20..34f33ad 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory4.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory4 : IDXGIFactory4.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0xEA, 0xC6, 0x1B, 0x36, 0xEF, 0x4F, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory4 : IDXGIFactory4.Interface, INativeGui 0xE5, 0x16, 0x8A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory5.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory5.cs index 0ff917a..a7e3398 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory5.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory5.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory5 : IDXGIFactory5.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF5, 0xE1, 0x32, 0x76, 0x65, 0xEE, 0xCA, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory5 : IDXGIFactory5.Interface, INativeGui 0xF8, 0x83, 0x8D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory6.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory6.cs index 9eb1fd9..642b0c7 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory6.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory6.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory6 : IDXGIFactory6.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4F, 0x69, 0xB6, 0xC1, 0x09, 0xFF, 0xA9, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory6 : IDXGIFactory6.Interface, INativeGui 0x0A, 0x1D, 0x17 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory7.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory7.cs index 8523014..8d6f6c8 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory7.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactory7.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactory7 : IDXGIFactory7.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xED, 0x6E, 0x96, 0xA4, 0xDB, 0x76, 0xDA, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactory7 : IDXGIFactory7.Interface, INativeGui 0xFB, 0x20, 0xA8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactoryMedia.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactoryMedia.cs index 1f04d86..4f479e4 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactoryMedia.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIFactoryMedia.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIFactoryMedia : IDXGIFactoryMedia.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF2, 0xD1, 0xE7, 0x41, 0x91, 0xA5, 0x7B, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIFactoryMedia : IDXGIFactoryMedia.Interface, IN 0x3E, 0x1C, 0x12 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIInfoQueue.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIInfoQueue.cs index 6b945ab..7efd566 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIInfoQueue.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIInfoQueue.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIInfoQueue : IDXGIInfoQueue.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC7, 0x41, 0x74, 0xD6, 0x2A, 0x67, 0x6F, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIInfoQueue : IDXGIInfoQueue.Interface, INativeG 0x49, 0x49, 0xCE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIKeyedMutex.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIKeyedMutex.cs index 1d2899d..c7400fa 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIKeyedMutex.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIKeyedMutex.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIKeyedMutex : IDXGIKeyedMutex.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x89, 0x12, 0x8E, 0x9D, 0xB3, 0xD7, 0x5F, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIKeyedMutex : IDXGIKeyedMutex.Interface, INativ 0x9A, 0xF8, 0x5D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIObject.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIObject.cs index bcf6efd..2db713b 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIObject.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIObject.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIObject : IDXGIObject.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB8, 0x2F, 0xC2, 0xAE, 0xF3, 0x76, 0x39, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIObject : IDXGIObject.Interface, INativeGuid 0xA6, 0x7A, 0x2E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput.cs index 9d1464f..a6578cb 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput : IDXGIOutput.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0xEE, 0x02, 0xAE, 0x35, 0xC7, 0x90, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput : IDXGIOutput.Interface, INativeGuid 0x02, 0x13, 0xAA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput1.cs index cccb502..a2ae448 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput1 : IDXGIOutput1.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA8, 0xDE, 0xCD, 0x00, 0x9B, 0x93, 0x83, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput1 : IDXGIOutput1.Interface, INativeGuid 0x66, 0x66, 0xCC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput2.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput2.cs index 66f7d81..2f96a0d 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput2.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput2 : IDXGIOutput2.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD1, 0x39, 0x5E, 0x59, 0x24, 0x27, 0x63, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput2 : IDXGIOutput2.Interface, INativeGuid 0xE2, 0x83, 0x64 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput3.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput3.cs index b3fd871..0cd5d42 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput3.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput3 : IDXGIOutput3.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0xB3, 0x6B, 0x8A, 0x7E, 0x7E, 0xF4, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput3 : IDXGIOutput3.Interface, INativeGuid 0xF9, 0x9B, 0x18 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput4.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput4.cs index 7e34f4b..7328562 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput4.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput4 : IDXGIOutput4.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x35, 0xCA, 0x7D, 0xDC, 0x96, 0x21, 0x4D, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput4 : IDXGIOutput4.Interface, INativeGuid 0x03, 0x2A, 0x60 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput5.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput5.cs index ebfa130..777391e 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput5.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput5.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput5 : IDXGIOutput5.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0x74, 0xA0, 0x80, 0x52, 0xAB, 0xEB, 0x42, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput5 : IDXGIOutput5.Interface, INativeGuid 0x28, 0x2D, 0x98 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput6.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput6.cs index afc3871..b770483 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput6.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutput6.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutput6 : IDXGIOutput6.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE8, 0x46, 0x83, 0x06, 0xEC, 0xAA, 0x84, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutput6 : IDXGIOutput6.Interface, INativeGuid 0x3F, 0x77, 0xA1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutputDuplication.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutputDuplication.cs index 4d56803..fba92b6 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutputDuplication.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIOutputDuplication.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIOutputDuplication : IDXGIOutputDuplication.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0xFA, 0x1C, 0x19, 0x41, 0xA3, 0x0D, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIOutputDuplication : IDXGIOutputDuplication.Int 0x28, 0x31, 0x9C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource.cs index 843b247..a143da4 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIResource : IDXGIResource.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB4, 0x3A, 0x5F, 0x03, 0x2E, 0x48, 0x50, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIResource : IDXGIResource.Interface, INativeGui 0xD8, 0x96, 0x0B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource1.cs index ccf617f..9db38be 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGIResource1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGIResource1 : IDXGIResource1.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x79, 0x13, 0x96, 0x30, 0x09, 0x46, 0x41, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGIResource1 : IDXGIResource1.Interface, INativeG 0x7E, 0xE0, 0xC1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface.cs index 71fa39f..d0e426c 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISurface : IDXGISurface.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6C, 0xB5, 0xFC, 0xCA, 0xC3, 0x6A, 0x89, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISurface : IDXGISurface.Interface, INativeGuid 0xD2, 0x60, 0xEC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface1.cs index c80a432..6e822fb 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISurface1 : IDXGISurface1.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x92, 0x30, 0xE6, 0x4A, 0x27, 0x63, 0x1B, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISurface1 : IDXGISurface1.Interface, INativeGui 0xA3, 0x2B, 0x86 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface2.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface2.cs index 37df991..a938465 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface2.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISurface2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISurface2 : IDXGISurface2.Interface, INativeGui [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDD, 0x96, 0xA4, 0xAB, 0x17, 0xB6, 0xB8, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISurface2 : IDXGISurface2.Interface, INativeGui 0xEB, 0x1F, 0xA2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain.cs index 156aef1..81c01d0 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISwapChain : IDXGISwapChain.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA0, 0x36, 0x0D, 0x31, 0xE7, 0xD2, 0x0A, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISwapChain : IDXGISwapChain.Interface, INativeG 0xB8, 0x88, 0x6A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain1.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain1.cs index 401fe4c..aeda281 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain1.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain1.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISwapChain1 : IDXGISwapChain1.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF7, 0x45, 0x0A, 0x79, 0x42, 0x0D, 0x76, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISwapChain1 : IDXGISwapChain1.Interface, INativ 0xE6, 0xF4, 0xAA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain2.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain2.cs index 1737c44..7a98dc0 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain2.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISwapChain2 : IDXGISwapChain2.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0x2A, 0xBE, 0xA8, 0x9F, 0x19, 0x46, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISwapChain2 : IDXGISwapChain2.Interface, INativ 0xB9, 0x8D, 0xE7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain3.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain3.cs index 5fb6770..d4ab22d 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain3.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain3.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISwapChain3 : IDXGISwapChain3.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDB, 0x9B, 0xD9, 0x94, 0xF8, 0xF1, 0xB0, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISwapChain3 : IDXGISwapChain3.Interface, INativ 0x0E, 0xDA, 0xB1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain4.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain4.cs index 9a98e06..f8a52dd 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain4.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChain4.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISwapChain4 : IDXGISwapChain4.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5A, 0x5D, 0x58, 0x3D, 0x4A, 0xBD, 0x9E, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISwapChain4 : IDXGISwapChain4.Interface, INativ 0x45, 0x2F, 0xFB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChainMedia.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChainMedia.cs index da19bd7..057bc2f 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChainMedia.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGISwapChainMedia.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGISwapChainMedia : IDXGISwapChainMedia.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0B, 0xB9, 0x95, 0xDD, 0x5F, 0xF0, 0x6A, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGISwapChainMedia : IDXGISwapChainMedia.Interface 0x64, 0xBD, 0x84 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGraphicsAnalysis.cs b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGraphicsAnalysis.cs index 556aafc..b0b6f68 100644 --- a/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGraphicsAnalysis.cs +++ b/src/Vortice.Win32.Graphics.Dxgi/Generated/IDXGraphicsAnalysis.cs @@ -21,7 +21,7 @@ public unsafe partial struct IDXGraphicsAnalysis : IDXGraphicsAnalysis.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x14, 0x15, 0x25, 0x9F, 0x4D, 0x9D, 0x02, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IDXGraphicsAnalysis : IDXGraphicsAnalysis.Interface 0xB7, 0xD4, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Apis.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Apis.cs index 1d3ffad..0264d5c 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Apis.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Apis.cs @@ -22,7 +22,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0xF2, 0xCA, 0xCA, 0x70, 0x93, 0x15, 0x46, @@ -34,7 +34,7 @@ public static partial class Apis 0xDA, 0x4C, 0x0A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -46,7 +46,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0xF2, 0xCA, 0xCA, 0x70, 0x93, 0x15, 0x46, @@ -58,7 +58,7 @@ public static partial class Apis 0xDA, 0x4C, 0x0A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -70,7 +70,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE8, 0x06, 0x7D, 0x31, 0x24, 0x5F, 0x3D, 0x43, @@ -82,7 +82,7 @@ public static partial class Apis 0xD8, 0xAB, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -96,7 +96,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0x49, 0xE7, 0xF0, 0xEF, 0xED, 0x89, 0x45, @@ -108,7 +108,7 @@ public static partial class Apis 0x6A, 0x2A, 0x2B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -120,7 +120,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFD, 0x30, 0x7A, 0x25, 0xB6, 0x06, 0x2B, 0x46, @@ -132,7 +132,7 @@ public static partial class Apis 0x86, 0xE5, 0x33 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -144,7 +144,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7B, 0xA1, 0x9E, 0x38, 0x78, 0x50, 0xDE, 0x4C, @@ -156,7 +156,7 @@ public static partial class Apis 0x75, 0xC7, 0x51 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -168,7 +168,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7B, 0xA1, 0x9E, 0x38, 0x78, 0x50, 0xDE, 0x4C, @@ -180,7 +180,7 @@ public static partial class Apis 0x75, 0xC7, 0x51 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -192,7 +192,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0x94, 0x18, 0xE0, 0x86, 0xAA, 0x08, 0x40, @@ -204,7 +204,7 @@ public static partial class Apis 0xE4, 0x0C, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -216,7 +216,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0x20, 0x46, 0x6B, 0xBF, 0x7C, 0x0D, 0x40, @@ -228,7 +228,7 @@ public static partial class Apis 0x0F, 0x27, 0x78 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -240,7 +240,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDF, 0xFC, 0x1B, 0xC6, 0x0F, 0x2E, 0xAD, 0x4A, @@ -252,7 +252,7 @@ public static partial class Apis 0xEB, 0xCD, 0xFE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -264,7 +264,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x80, 0xA4, 0x56, 0x94, 0x8B, 0xE8, 0xEA, 0x43, @@ -276,7 +276,7 @@ public static partial class Apis 0x71, 0xB1, 0xCA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -288,7 +288,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3C, 0xDA, 0x1D, 0x38, 0xE9, 0x9C, 0x34, 0x48, @@ -300,7 +300,7 @@ public static partial class Apis 0xFC, 0x52, 0xBE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -312,7 +312,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD9, 0x85, 0x4E, 0xB5, 0x23, 0xFE, 0x9F, 0x49, @@ -324,7 +324,7 @@ public static partial class Apis 0x13, 0x75, 0x2B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -336,7 +336,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0xEC, 0x6C, 0xA2, 0x4C, 0x23, 0x50, 0x49, @@ -348,7 +348,7 @@ public static partial class Apis 0xE7, 0x1D, 0x0D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -360,7 +360,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9F, 0x69, 0x53, 0x90, 0x41, 0xA3, 0x9D, 0x42, @@ -372,7 +372,7 @@ public static partial class Apis 0xF8, 0x0C, 0x73 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -384,7 +384,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB4, 0x8B, 0xBE, 0x69, 0x6D, 0xD6, 0xC8, 0x47, @@ -396,7 +396,7 @@ public static partial class Apis 0x43, 0x37, 0x82 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -408,7 +408,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x69, 0x99, 0x94, 0x27, 0x6A, 0x87, 0xD7, 0x41, @@ -420,7 +420,7 @@ public static partial class Apis 0x35, 0xA4, 0xDC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -432,7 +432,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC1, 0xF5, 0x34, 0x1A, 0x5A, 0x4A, 0xDC, 0x46, @@ -444,7 +444,7 @@ public static partial class Apis 0xE7, 0xA6, 0x76 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -456,7 +456,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x98, 0x55, 0x4F, 0x11, 0x22, 0x0B, 0xA0, 0x40, @@ -468,7 +468,7 @@ public static partial class Apis 0x95, 0xAD, 0xBD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -480,7 +480,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x10, 0xBE, 0x31, 0x01, 0x01, 0x20, 0x5F, 0x4C, @@ -492,7 +492,7 @@ public static partial class Apis 0xB6, 0x4C, 0xE8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -504,7 +504,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCB, 0xE3, 0x4C, 0xAC, 0xC1, 0xE1, 0xCD, 0x44, @@ -516,7 +516,7 @@ public static partial class Apis 0x50, 0x9E, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -528,7 +528,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x94, 0xDE, 0x1D, 0xA6, 0xCE, 0x66, 0xC1, 0x4A, @@ -540,7 +540,7 @@ public static partial class Apis 0x88, 0x89, 0x5E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -552,7 +552,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x11, 0x94, 0x1D, 0x98, 0x9E, 0x90, 0xA7, 0x42, @@ -564,7 +564,7 @@ public static partial class Apis 0x05, 0x2E, 0xDB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -576,7 +576,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x62, 0x5C, 0xED, 0x68, 0x34, 0xF5, 0x79, 0x49, @@ -588,7 +588,7 @@ public static partial class Apis 0xB2, 0xB3, 0x4C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -600,7 +600,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0A, 0xA8, 0xA4, 0xE9, 0xFE, 0x44, 0xE4, 0x4D, @@ -612,7 +612,7 @@ public static partial class Apis 0x0A, 0x51, 0x99 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -624,7 +624,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC1, 0xCE, 0xBE, 0x0D, 0xB3, 0x9E, 0x60, 0x48, @@ -636,7 +636,7 @@ public static partial class Apis 0x63, 0x45, 0x75 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -648,7 +648,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x86, 0xE8, 0x93, 0x76, 0xC9, 0x51, 0x70, 0x40, @@ -660,7 +660,7 @@ public static partial class Apis 0x8E, 0xC8, 0xFA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -672,7 +672,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0x57, 0x94, 0x41, 0x02, 0x83, 0xA6, 0x44, @@ -684,7 +684,55 @@ public static partial class Apis 0xAF, 0xA0, 0x86 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegXLDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xCE, 0xEE, 0x6C, 0xFC, + 0xF5, 0xAE, + 0x23, 0x4A, + 0x96, + 0xEC, + 0x59, + 0x84, + 0xFF, + 0xB4, + 0x86, + 0xD9 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegXLEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x3B, 0xCD, 0x4E, 0x0E, + 0xA6, 0x1B, + 0x36, 0x46, + 0x81, + 0x98, + 0x56, + 0xC7, + 0x30, + 0x40, + 0x96, + 0x4A + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -696,7 +744,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7E, 0xD8, 0xF1, 0x0A, 0xFE, 0xFC, 0x88, 0x41, @@ -708,7 +756,7 @@ public static partial class Apis 0x71, 0xCB, 0xE3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -720,7 +768,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF4, 0xFA, 0x7C, 0x1B, 0x3F, 0x71, 0x3C, 0x47, @@ -732,7 +780,7 @@ public static partial class Apis 0x5F, 0xAE, 0xAF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -744,7 +792,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0x60, 0xA8, 0xA3, 0x8F, 0x33, 0x17, 0x4C, @@ -756,7 +804,7 @@ public static partial class Apis 0x62, 0x8F, 0x21 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -768,7 +816,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0xA5, 0xE4, 0x19, 0x62, 0x56, 0xC5, 0x4F, @@ -780,7 +828,7 @@ public static partial class Apis 0x8E, 0x10, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -792,7 +840,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x30, 0xCC, 0x3B, 0x16, 0xE9, 0xE2, 0x0B, 0x4F, @@ -804,7 +852,7 @@ public static partial class Apis 0xB7, 0x88, 0xA3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -816,7 +864,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0x56, 0x8A, 0x1F, 0x4D, 0x7D, 0xBD, 0x4C, @@ -828,7 +876,7 @@ public static partial class Apis 0xEE, 0xB9, 0xA5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -840,7 +888,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAA, 0x7C, 0xA3, 0x57, 0x7A, 0x36, 0x40, 0x45, @@ -852,7 +900,7 @@ public static partial class Apis 0x09, 0x3A, 0x4B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -864,7 +912,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x95, 0xCB, 0x67, 0x99, 0x85, 0x2E, 0xC8, 0x4A, @@ -876,7 +924,7 @@ public static partial class Apis 0xD4, 0x25, 0xC9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -888,7 +936,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0D, 0x6D, 0xFF, 0xF3, 0xC0, 0x38, 0xC4, 0x41, @@ -900,7 +948,7 @@ public static partial class Apis 0xF1, 0x7B, 0x84 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -912,7 +960,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x21, 0x25, 0xE6, 0xE1, 0x87, 0x67, 0x5B, 0x40, @@ -924,7 +972,7 @@ public static partial class Apis 0xB5, 0x76, 0x3F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -936,7 +984,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE2, 0xB0, 0x94, 0xE0, 0xF2, 0x67, 0xB3, 0x45, @@ -948,7 +996,7 @@ public static partial class Apis 0xCA, 0x7C, 0xF3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -960,7 +1008,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x60, 0xCE, 0x99, 0xFE, 0x9C, 0xF1, 0x3C, 0x43, @@ -972,7 +1020,31 @@ public static partial class Apis 0xA9, 0xCA, 0x21 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatJpegXL + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x3F, 0x4E, 0xC1, 0xFE, + 0x7A, 0x42, + 0x36, 0x47, + 0xAA, + 0xE6, + 0x27, + 0xED, + 0x84, + 0xF6, + 0x93, + 0x22 + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -984,7 +1056,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x80, 0xD3, 0xE3, 0xFA, 0xA4, 0xFE, 0x23, 0x46, @@ -996,7 +1068,7 @@ public static partial class Apis 0x10, 0xB6, 0x81 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1008,7 +1080,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0x68, 0xD9, 0x7E, 0xF0, 0x96, 0x12, 0x48, @@ -1020,7 +1092,7 @@ public static partial class Apis 0x11, 0x7E, 0xD3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1032,7 +1104,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x96, 0x72, 0x75, 0xAC, 0x22, 0x35, 0x11, 0x4E, @@ -1044,7 +1116,7 @@ public static partial class Apis 0xA1, 0x76, 0x7E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1056,7 +1128,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0F, 0xE7, 0x46, 0x2B, 0xA7, 0xCD, 0x3E, 0x47, @@ -1068,7 +1140,7 @@ public static partial class Apis 0xA2, 0x39, 0x0B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1080,7 +1152,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE8, 0xEA, 0x35, 0x78, 0x14, 0xBF, 0xD1, 0x49, @@ -1092,7 +1164,7 @@ public static partial class Apis 0x7B, 0x22, 0x48 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1104,7 +1176,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD8, 0x94, 0xAF, 0x05, 0x74, 0x71, 0xD2, 0x4C, @@ -1116,7 +1188,7 @@ public static partial class Apis 0x0E, 0xE4, 0xB8 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1128,7 +1200,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA4, 0xB9, 0xE3, 0xAB, 0x7D, 0x25, 0x97, 0x4B, @@ -1140,7 +1212,7 @@ public static partial class Apis 0x96, 0x22, 0x2E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1152,7 +1224,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDC, 0x11, 0x3F, 0x1A, 0x14, 0xB5, 0x17, 0x4B, @@ -1164,7 +1236,7 @@ public static partial class Apis 0x38, 0x52, 0xF1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1176,7 +1248,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x54, 0xD4, 0x75, 0xAC, 0x37, 0x9F, 0xF8, 0x48, @@ -1188,7 +1260,7 @@ public static partial class Apis 0x85, 0x60, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1200,7 +1272,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB2, 0xAB, 0x7C, 0xC1, 0xA3, 0xD4, 0xD7, 0x47, @@ -1212,7 +1284,7 @@ public static partial class Apis 0xFB, 0xD4, 0xF1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1224,7 +1296,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2B, 0x17, 0xB5, 0x9C, 0x00, 0xD6, 0xBA, 0x46, @@ -1236,7 +1308,7 @@ public static partial class Apis 0x3A, 0x00, 0xD9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1248,7 +1320,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB8, 0x32, 0x41, 0x18, 0xF8, 0x32, 0x84, 0x47, @@ -1260,7 +1332,7 @@ public static partial class Apis 0xB2, 0x34, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1294,7 +1366,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1306,7 +1378,7 @@ public static partial class Apis 0x8D, 0xC9, 0x00 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1318,7 +1390,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1330,7 +1402,7 @@ public static partial class Apis 0x8D, 0xC9, 0x01 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1342,7 +1414,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1354,7 +1426,7 @@ public static partial class Apis 0x8D, 0xC9, 0x02 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1366,7 +1438,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1378,7 +1450,7 @@ public static partial class Apis 0x8D, 0xC9, 0x03 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1390,7 +1462,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1402,7 +1474,7 @@ public static partial class Apis 0x8D, 0xC9, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1414,7 +1486,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1426,7 +1498,7 @@ public static partial class Apis 0x8D, 0xC9, 0x05 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1438,7 +1510,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1450,7 +1522,7 @@ public static partial class Apis 0x8D, 0xC9, 0x06 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1462,7 +1534,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1474,7 +1546,7 @@ public static partial class Apis 0x8D, 0xC9, 0x07 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1486,7 +1558,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1498,7 +1570,7 @@ public static partial class Apis 0x8D, 0xC9, 0x08 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1510,7 +1582,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x16, 0x01, 0xCD, 0xE6, 0xBA, 0xEE, 0x61, 0x41, @@ -1522,7 +1594,55 @@ public static partial class Apis 0xB3, 0xA8, 0x95 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppDepth + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x45, 0x9F, 0x9C, 0x4C, + 0x89, 0x1D, + 0x31, 0x4E, + 0x9B, + 0xC7, + 0x69, + 0x34, + 0x3A, + 0x0D, + 0xCA, + 0x69 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppGain + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x2A, 0x02, 0x84, 0xA8, + 0x13, 0xAF, + 0x16, 0x4C, + 0xB7, + 0x46, + 0x61, + 0x9B, + 0xF6, + 0x18, + 0xB8, + 0x78 + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1534,7 +1654,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1546,7 +1666,7 @@ public static partial class Apis 0x8D, 0xC9, 0x09 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1558,7 +1678,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1570,7 +1690,7 @@ public static partial class Apis 0x8D, 0xC9, 0x0A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1582,7 +1702,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2B, 0x7C, 0xEC, 0x05, 0xE6, 0xF1, 0x61, 0x49, @@ -1594,7 +1714,7 @@ public static partial class Apis 0x0A, 0x87, 0xD2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1606,7 +1726,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1618,7 +1738,7 @@ public static partial class Apis 0x8D, 0xC9, 0x0B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1630,7 +1750,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1642,7 +1762,7 @@ public static partial class Apis 0x8D, 0xC9, 0x0C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1654,7 +1774,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1666,7 +1786,7 @@ public static partial class Apis 0x8D, 0xC9, 0x0D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1678,7 +1798,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1690,7 +1810,7 @@ public static partial class Apis 0x8D, 0xC9, 0x0E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1702,7 +1822,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1714,7 +1834,7 @@ public static partial class Apis 0x8D, 0xC9, 0x0F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1726,7 +1846,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1738,7 +1858,7 @@ public static partial class Apis 0x8D, 0xC9, 0x10 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1750,7 +1870,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1762,7 +1882,7 @@ public static partial class Apis 0x8D, 0xC9, 0x11 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1774,7 +1894,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x95, 0x6B, 0x8C, 0xD9, 0xFE, 0x3E, 0xD6, 0x47, @@ -1786,7 +1906,7 @@ public static partial class Apis 0xAB, 0x0C, 0xF1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1798,7 +1918,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2D, 0xAD, 0xC7, 0xF5, 0x8D, 0x6A, 0xDD, 0x43, @@ -1810,7 +1930,7 @@ public static partial class Apis 0x26, 0x1A, 0xE9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1822,7 +1942,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x50, 0xA6, 0xC4, 0x3C, 0x27, 0xA5, 0x37, 0x4D, @@ -1834,7 +1954,7 @@ public static partial class Apis 0xEB, 0xED, 0xBA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1846,7 +1966,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1858,7 +1978,7 @@ public static partial class Apis 0x8D, 0xC9, 0x15 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1870,7 +1990,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x84, 0xA3, 0x05, 0xE6, 0x68, 0xB4, 0xCE, 0x46, @@ -1882,7 +2002,7 @@ public static partial class Apis 0xE6, 0x43, 0x13 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1894,7 +2014,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x11, 0x21, 0x18, 0xA1, 0x6D, 0x18, 0x42, 0x4D, @@ -1906,7 +2026,7 @@ public static partial class Apis 0xA8, 0xDF, 0xF9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1918,7 +2038,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1930,7 +2050,7 @@ public static partial class Apis 0x8D, 0xC9, 0x16 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1942,7 +2062,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7C, 0xFF, 0x62, 0x15, 0x52, 0xD3, 0xF9, 0x46, @@ -1954,7 +2074,7 @@ public static partial class Apis 0x79, 0x22, 0x46 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1966,7 +2086,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -1978,7 +2098,7 @@ public static partial class Apis 0x8D, 0xC9, 0x17 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -1990,7 +2110,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8E, 0x8E, 0x51, 0x8C, 0xEC, 0xA4, 0x8B, 0x46, @@ -2002,7 +2122,7 @@ public static partial class Apis 0x9C, 0x55, 0x30 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2014,7 +2134,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2026,7 +2146,7 @@ public static partial class Apis 0x8D, 0xC9, 0x13 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2038,7 +2158,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2050,7 +2170,7 @@ public static partial class Apis 0x8D, 0xC9, 0x14 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2062,7 +2182,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2074,7 +2194,7 @@ public static partial class Apis 0x8D, 0xC9, 0x12 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2086,7 +2206,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0E, 0x14, 0xCA, 0x49, 0xB6, 0xCA, 0x3B, 0x49, @@ -2098,7 +2218,7 @@ public static partial class Apis 0x37, 0x53, 0x2A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2110,7 +2230,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2122,7 +2242,7 @@ public static partial class Apis 0x8D, 0xC9, 0x18 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2134,7 +2254,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8F, 0xD7, 0xFE, 0xE3, 0xDB, 0xE8, 0xCF, 0x4A, @@ -2146,7 +2266,7 @@ public static partial class Apis 0x36, 0xB3, 0x27 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2158,7 +2278,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2170,7 +2290,7 @@ public static partial class Apis 0x8D, 0xC9, 0x19 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2182,7 +2302,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2194,7 +2314,7 @@ public static partial class Apis 0x8D, 0xC9, 0x1A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2206,7 +2326,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2218,7 +2338,7 @@ public static partial class Apis 0x8D, 0xC9, 0x1B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2230,7 +2350,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2242,7 +2362,7 @@ public static partial class Apis 0x8D, 0xC9, 0x1C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2254,7 +2374,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2266,7 +2386,7 @@ public static partial class Apis 0x8D, 0xC9, 0x1D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2278,7 +2398,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3C, 0xE3, 0x6D, 0x35, 0xD2, 0x54, 0x23, 0x4A, @@ -2290,7 +2410,7 @@ public static partial class Apis 0xB1, 0xD4, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2302,7 +2422,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2314,7 +2434,7 @@ public static partial class Apis 0x8D, 0xC9, 0x40 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2326,7 +2446,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2338,7 +2458,7 @@ public static partial class Apis 0x8D, 0xC9, 0x1E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2350,7 +2470,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2362,7 +2482,7 @@ public static partial class Apis 0x8D, 0xC9, 0x41 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2374,7 +2494,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2386,7 +2506,7 @@ public static partial class Apis 0x8D, 0xC9, 0x3A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2398,7 +2518,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC2, 0x26, 0xAD, 0x58, 0x23, 0xC6, 0x9D, 0x4D, @@ -2410,7 +2530,7 @@ public static partial class Apis 0xF8, 0xC4, 0x42 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2422,7 +2542,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2434,7 +2554,7 @@ public static partial class Apis 0x8D, 0xC9, 0x42 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2446,7 +2566,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2458,7 +2578,7 @@ public static partial class Apis 0x8D, 0xC9, 0x3B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2470,7 +2590,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2482,7 +2602,7 @@ public static partial class Apis 0x8D, 0xC9, 0x3D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2494,7 +2614,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2506,7 +2626,7 @@ public static partial class Apis 0x8D, 0xC9, 0x3E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2518,7 +2638,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2530,7 +2650,7 @@ public static partial class Apis 0x8D, 0xC9, 0x3F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2542,7 +2662,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x72, 0x8D, 0x23, 0x25, 0xF9, 0xFC, 0x22, 0x45, @@ -2554,7 +2674,7 @@ public static partial class Apis 0xAD, 0x55, 0xE0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2566,7 +2686,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9A, 0x6B, 0xDE, 0x00, 0x01, 0xC1, 0x4B, 0x43, @@ -2578,7 +2698,7 @@ public static partial class Apis 0xE1, 0x12, 0x2C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2590,7 +2710,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB5, 0x1B, 0x4E, 0x60, 0x3C, 0x8A, 0x65, 0x4B, @@ -2602,7 +2722,7 @@ public static partial class Apis 0xD7, 0x5B, 0x7F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2614,7 +2734,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5D, 0x5C, 0x21, 0x9C, 0xCC, 0x1A, 0x0E, 0x4F, @@ -2626,7 +2746,7 @@ public static partial class Apis 0xE8, 0xFD, 0x28 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2638,7 +2758,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2650,7 +2770,7 @@ public static partial class Apis 0x8D, 0xC9, 0x1F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2662,7 +2782,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2674,7 +2794,7 @@ public static partial class Apis 0x8D, 0xC9, 0x20 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2686,7 +2806,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2698,7 +2818,7 @@ public static partial class Apis 0x8D, 0xC9, 0x21 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2710,7 +2830,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2722,7 +2842,7 @@ public static partial class Apis 0x8D, 0xC9, 0x22 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2734,7 +2854,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2746,7 +2866,7 @@ public static partial class Apis 0x8D, 0xC9, 0x23 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2758,7 +2878,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2770,7 +2890,7 @@ public static partial class Apis 0x8D, 0xC9, 0x24 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2782,7 +2902,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2794,7 +2914,7 @@ public static partial class Apis 0x8D, 0xC9, 0x25 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2806,7 +2926,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2818,7 +2938,7 @@ public static partial class Apis 0x8D, 0xC9, 0x26 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2830,7 +2950,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2842,7 +2962,7 @@ public static partial class Apis 0x8D, 0xC9, 0x27 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2854,7 +2974,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2866,7 +2986,7 @@ public static partial class Apis 0x8D, 0xC9, 0x28 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2878,7 +2998,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2890,7 +3010,7 @@ public static partial class Apis 0x8D, 0xC9, 0x29 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2902,7 +3022,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2914,7 +3034,7 @@ public static partial class Apis 0x8D, 0xC9, 0x2A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2926,7 +3046,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2938,7 +3058,7 @@ public static partial class Apis 0x8D, 0xC9, 0x2B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2950,7 +3070,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2962,7 +3082,7 @@ public static partial class Apis 0x8D, 0xC9, 0x2C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2974,7 +3094,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -2986,7 +3106,7 @@ public static partial class Apis 0x8D, 0xC9, 0x2D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -2998,7 +3118,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3010,7 +3130,7 @@ public static partial class Apis 0x8D, 0xC9, 0x2E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3022,7 +3142,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3034,7 +3154,7 @@ public static partial class Apis 0x8D, 0xC9, 0x2F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3046,7 +3166,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3058,7 +3178,7 @@ public static partial class Apis 0x8D, 0xC9, 0x30 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3070,7 +3190,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3082,7 +3202,7 @@ public static partial class Apis 0x8D, 0xC9, 0x31 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3094,7 +3214,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3106,7 +3226,7 @@ public static partial class Apis 0x8D, 0xC9, 0x32 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3118,7 +3238,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3130,7 +3250,7 @@ public static partial class Apis 0x8D, 0xC9, 0x33 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3142,7 +3262,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3154,7 +3274,7 @@ public static partial class Apis 0x8D, 0xC9, 0x34 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3166,7 +3286,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3178,7 +3298,7 @@ public static partial class Apis 0x8D, 0xC9, 0x35 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3190,7 +3310,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3202,7 +3322,7 @@ public static partial class Apis 0x8D, 0xC9, 0x36 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3214,7 +3334,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3226,7 +3346,7 @@ public static partial class Apis 0x8D, 0xC9, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3238,7 +3358,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3250,7 +3370,7 @@ public static partial class Apis 0x8D, 0xC9, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3262,7 +3382,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xC3, 0xDD, 0x6F, 0x03, 0x4E, 0xFE, 0x4B, @@ -3274,7 +3394,7 @@ public static partial class Apis 0x8D, 0xC9, 0x39 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3286,7 +3406,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x54, 0xDB, 0xB4, 0x91, 0xF9, 0x2D, 0xF0, 0x42, @@ -3298,7 +3418,7 @@ public static partial class Apis 0x3D, 0xF8, 0x8E - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3310,7 +3430,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x24, 0xF2, 0x39, 0x13, 0xFE, 0x6B, 0x3E, 0x4C, @@ -3322,7 +3442,7 @@ public static partial class Apis 0xD0, 0xCA, 0x2A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3334,7 +3454,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x53, 0x50, 0x14, 0xB8, 0x16, 0x21, 0xF0, 0x49, @@ -3346,7 +3466,7 @@ public static partial class Apis 0x20, 0x5C, 0x51 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3358,7 +3478,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0xBA, 0x95, 0xFF, 0xE0, 0x11, 0x63, 0x42, @@ -3370,7 +3490,7 @@ public static partial class Apis 0x34, 0x60, 0xA4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3382,7 +3502,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x33, 0xF4, 0x55, 0xA3, 0xE8, 0x48, 0x42, 0x4A, @@ -3394,7 +3514,7 @@ public static partial class Apis 0xCA, 0x80, 0xA4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3406,7 +3526,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x61, 0xFF, 0xC4, 0xD2, 0xA5, 0x56, 0xC2, 0x49, @@ -3418,7 +3538,7 @@ public static partial class Apis 0x96, 0x48, 0x37 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3430,7 +3550,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF0, 0x54, 0xE3, 0x2F, 0x80, 0x16, 0xD8, 0x42, @@ -3442,7 +3562,7 @@ public static partial class Apis 0x65, 0xBF, 0xC1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3498,7 +3618,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2F, 0x59, 0x5E, 0xA4, 0x78, 0x90, 0x7C, 0x4A, @@ -3510,7 +3630,7 @@ public static partial class Apis 0xD6, 0x1B, 0x1F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3522,7 +3642,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC6, 0x96, 0x73, 0x53, 0x8A, 0x2D, 0xB6, 0x4B, @@ -3534,7 +3654,7 @@ public static partial class Apis 0x2A, 0x3A, 0xDF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3546,7 +3666,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x28, 0xE1, 0xA2, 0x58, 0xB9, 0x2D, 0x57, 0x4E, @@ -3558,7 +3678,7 @@ public static partial class Apis 0x1E, 0xD3, 0x31 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3570,7 +3690,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9D, 0x4F, 0x3C, 0x1C, 0x4A, 0xB8, 0x7D, 0x46, @@ -3582,7 +3702,7 @@ public static partial class Apis 0x59, 0xEA, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3594,7 +3714,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0xAB, 0x34, 0x71, 0x51, 0x93, 0xAD, 0x44, @@ -3606,7 +3726,7 @@ public static partial class Apis 0xB5, 0x02, 0xEC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3618,7 +3738,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8E, 0x6F, 0x68, 0xED, 0x1F, 0x68, 0x8B, 0x4C, @@ -3630,7 +3750,7 @@ public static partial class Apis 0xF6, 0xB3, 0xFC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3642,7 +3762,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x28, 0x70, 0x00, 0x79, 0x8D, 0x26, 0xD6, 0x45, @@ -3654,7 +3774,7 @@ public static partial class Apis 0x50, 0x4B, 0xC9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3666,7 +3786,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC3, 0xDF, 0xD3, 0x8F, 0x51, 0xF9, 0x2B, 0x49, @@ -3678,7 +3798,7 @@ public static partial class Apis 0xD9, 0xA5, 0xB0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3690,7 +3810,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0x56, 0x65, 0x32, 0x02, 0xF5, 0x54, 0x43, @@ -3702,7 +3822,7 @@ public static partial class Apis 0xEA, 0xF6, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3714,7 +3834,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x14, 0x09, 0xAB, 0x4F, 0x29, 0xE1, 0x87, 0x40, @@ -3726,7 +3846,7 @@ public static partial class Apis 0x45, 0xA7, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3738,7 +3858,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0x0D, 0x10, 0x16, 0x70, 0x85, 0xB9, 0x4B, @@ -3750,7 +3870,7 @@ public static partial class Apis 0x3E, 0xCE, 0x67 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3762,7 +3882,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8C, 0x56, 0x10, 0x00, 0x52, 0x08, 0x6A, 0x4E, @@ -3774,7 +3894,7 @@ public static partial class Apis 0x5B, 0x04, 0x30 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3786,7 +3906,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5D, 0x30, 0x9F, 0x73, 0xDB, 0x81, 0xCB, 0x43, @@ -3798,7 +3918,7 @@ public static partial class Apis 0xF9, 0xF0, 0x03 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3810,7 +3930,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x85, 0x22, 0xA3, 0x1C, 0xCD, 0x9C, 0x86, 0x47, @@ -3822,7 +3942,7 @@ public static partial class Apis 0xB6, 0xA0, 0x06 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3834,7 +3954,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x38, 0xCC, 0x5A, 0xBB, 0x16, 0xF2, 0xEC, 0x4C, @@ -3846,7 +3966,7 @@ public static partial class Apis 0x97, 0x63, 0xA9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3858,7 +3978,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE9, 0xCE, 0x3D, 0x24, 0x03, 0x87, 0xEE, 0x40, @@ -3870,7 +3990,7 @@ public static partial class Apis 0xB8, 0x05, 0x8C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3882,7 +4002,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0x89, 0x8D, 0x56, 0xA9, 0xC0, 0x23, 0x49, @@ -3894,7 +4014,7 @@ public static partial class Apis 0x23, 0x8F, 0xBC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3906,7 +4026,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF1, 0x3C, 0x38, 0x22, 0x17, 0xED, 0x2E, 0x4E, @@ -3918,7 +4038,7 @@ public static partial class Apis 0x6B, 0x30, 0xD0 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3930,7 +4050,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5F, 0xCA, 0x3C, 0x83, 0xB7, 0xDC, 0x16, 0x45, @@ -3942,7 +4062,7 @@ public static partial class Apis 0x26, 0xDC, 0xE4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3954,7 +4074,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0xDF, 0xE8, 0x63, 0x6C, 0xEB, 0x6C, 0x45, @@ -3966,7 +4086,7 @@ public static partial class Apis 0x4F, 0xD6, 0x48 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -3978,7 +4098,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x75, 0xA6, 0x08, 0x7B, 0xAA, 0x91, 0x1B, 0x48, @@ -3990,7 +4110,7 @@ public static partial class Apis 0x08, 0x61, 0x3B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4002,7 +4122,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1E, 0x03, 0x56, 0xE2, 0x99, 0x62, 0x29, 0x49, @@ -4014,7 +4134,7 @@ public static partial class Apis 0xAF, 0xBA, 0x92 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4026,7 +4146,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x86, 0xB0, 0x2B, 0xBD, 0x52, 0x4D, 0xDD, 0x48, @@ -4038,7 +4158,7 @@ public static partial class Apis 0x85, 0xAE, 0x8F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4050,7 +4170,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD8, 0xCA, 0x25, 0x2A, 0xEB, 0xDE, 0x69, 0x4C, @@ -4062,7 +4182,7 @@ public static partial class Apis 0x6D, 0xCA, 0xFD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4074,7 +4194,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC2, 0x3D, 0x04, 0x2E, 0x67, 0xC9, 0x05, 0x4E, @@ -4086,7 +4206,7 @@ public static partial class Apis 0x7E, 0x85, 0xC3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4098,7 +4218,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCF, 0x0D, 0x3D, 0xF7, 0xC6, 0xCE, 0x85, 0x4F, @@ -4110,7 +4230,7 @@ public static partial class Apis 0xB1, 0xBE, 0xF7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4122,7 +4242,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x07, 0x80, 0x90, 0x86, 0xFC, 0xED, 0x60, 0x48, @@ -4134,7 +4254,7 @@ public static partial class Apis 0x3E, 0x60, 0x58 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4146,7 +4266,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x33, 0x5F, 0x0E, 0x22, 0xD3, 0xAF, 0x4E, 0x47, @@ -4158,7 +4278,7 @@ public static partial class Apis 0x30, 0xF5, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4170,7 +4290,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE0, 0xE0, 0xB6, 0xC4, 0xB4, 0xCF, 0xD3, 0x4A, @@ -4182,7 +4302,7 @@ public static partial class Apis 0x55, 0xA3, 0x4A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4194,7 +4314,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA5, 0x35, 0x09, 0xF0, 0x5D, 0x1D, 0xD1, 0x4C, @@ -4206,7 +4326,7 @@ public static partial class Apis 0xEC, 0xA7, 0x81 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4218,7 +4338,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x71, 0x35, 0x4D, 0xE1, 0x47, 0x6B, 0xEA, 0x4D, @@ -4230,7 +4350,7 @@ public static partial class Apis 0x78, 0xDF, 0xB7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4242,7 +4362,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x29, 0xC7, 0xBE, 0xC2, 0x68, 0x0B, 0x77, 0x4B, @@ -4254,7 +4374,7 @@ public static partial class Apis 0xAC, 0x18, 0x14 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4266,7 +4386,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0x65, 0xB3, 0x9D, 0x42, 0x28, 0xB3, 0x44, @@ -4278,7 +4398,7 @@ public static partial class Apis 0x75, 0x55, 0x6A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4290,7 +4410,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x82, 0x9A, 0xC5, 0x74, 0xDB, 0xA4, 0x48, @@ -4302,7 +4422,7 @@ public static partial class Apis 0x31, 0xEF, 0x95 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4314,7 +4434,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xAB, 0x49, 0x43, 0xEB, 0x85, 0xB6, 0x0F, 0x45, @@ -4326,7 +4446,7 @@ public static partial class Apis 0x92, 0x53, 0x6C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4338,7 +4458,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0xFD, 0x15, 0xC1, 0x6F, 0xCC, 0x3F, 0x4E, @@ -4350,7 +4470,7 @@ public static partial class Apis 0xC6, 0xB0, 0xD9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4362,7 +4482,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2D, 0xAE, 0x00, 0x6B, 0x4B, 0xE2, 0x0A, 0x46, @@ -4374,7 +4494,7 @@ public static partial class Apis 0x30, 0x72, 0xFD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4386,7 +4506,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x03, 0x46, 0x06, 0x4A, 0x33, 0x8C, 0x60, 0x4E, @@ -4398,7 +4518,7 @@ public static partial class Apis 0x70, 0x2D, 0x08 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4410,7 +4530,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE1, 0xF3, 0x7E, 0x81, 0x88, 0x12, 0xF4, 0x45, @@ -4422,7 +4542,7 @@ public static partial class Apis 0x7C, 0xCE, 0x83 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4434,7 +4554,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8A, 0x8D, 0x8B, 0x56, 0x65, 0x1E, 0x8C, 0x43, @@ -4446,7 +4566,7 @@ public static partial class Apis 0x12, 0xBE, 0xB9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4458,7 +4578,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0xFD, 0xC4, 0x6D, 0xE6, 0x78, 0x02, 0x41, @@ -4470,7 +4590,7 @@ public static partial class Apis 0xDC, 0xC7, 0x8B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4482,7 +4602,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEE, 0x05, 0xC1, 0x43, 0x3B, 0xB9, 0xBB, 0x4A, @@ -4494,7 +4614,55 @@ public static partial class Apis 0x87, 0x04, 0x71 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatJpegXLAnim + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x24, 0x2E, 0x1C, 0x50, + 0x7D, 0x7A, + 0xB2, 0x42, + 0x93, + 0xC7, + 0xB4, + 0xF4, + 0x5B, + 0xCC, + 0x92, + 0xF7 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatJpegXLAnimFrame + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x2C, 0xCC, 0x8E, 0x95, + 0xCB, 0x36, + 0xF9, 0x4A, + 0x9E, + 0xA8, + 0x0B, + 0x74, + 0xBA, + 0xCC, + 0xFD, + 0x3E + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4506,7 +4674,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC2, 0x45, 0x97, 0x69, 0x66, 0x50, 0x82, 0x4B, @@ -4518,7 +4686,7 @@ public static partial class Apis 0xDB, 0xEC, 0x8C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4530,7 +4698,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x86, 0xCA, 0x9C, 0xA0, 0xBA, 0x27, 0x39, 0x4F, @@ -4542,7 +4710,7 @@ public static partial class Apis 0xDC, 0x08, 0xFC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4554,7 +4722,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0x33, 0xC6, 0xF3, 0xC8, 0x46, 0x8E, 0x49, @@ -4566,7 +4734,7 @@ public static partial class Apis 0x1B, 0xBC, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4578,7 +4746,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x33, 0x4B, 0x32, 0x43, 0x8F, 0xA7, 0x0F, 0x48, @@ -4590,7 +4758,7 @@ public static partial class Apis 0xCC, 0xC8, 0x32 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4602,7 +4770,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x69, 0x60, 0x36, 0xEE, 0x32, 0x18, 0x0F, 0x42, @@ -4614,7 +4782,7 @@ public static partial class Apis 0x06, 0x6F, 0x19 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4626,7 +4794,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x13, 0x35, 0xE3, 0xDD, 0x4E, 0x77, 0xCD, 0x4B, @@ -4638,7 +4806,7 @@ public static partial class Apis 0xFE, 0x62, 0xFC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4650,7 +4818,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0xA9, 0x19, 0x7B, 0xD6, 0xA9, 0xE5, 0x49, @@ -4662,7 +4830,7 @@ public static partial class Apis 0x4E, 0x4C, 0xD5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4674,7 +4842,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x50, 0x3C, 0x7E, 0xAA, 0x4C, 0x86, 0x04, 0x46, @@ -4686,7 +4854,7 @@ public static partial class Apis 0xE6, 0x37, 0xF6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4698,7 +4866,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x56, 0x46, 0x91, 0x8F, 0x0A, 0x9D, 0xB2, 0x4E, @@ -4710,7 +4878,7 @@ public static partial class Apis 0x8A, 0x9E, 0xE6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4722,7 +4890,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x28, 0xFC, 0xEB, 0xB1, 0xBD, 0xC9, 0xA2, 0x47, @@ -4734,7 +4902,7 @@ public static partial class Apis 0x97, 0x77, 0xA7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4746,7 +4914,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x09, 0x2F, 0xD4, 0x50, 0xD1, 0xEC, 0x41, 0x4B, @@ -4758,7 +4926,7 @@ public static partial class Apis 0xA7, 0x56, 0x63 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4770,7 +4938,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x86, 0x53, 0xDE, 0x8A, 0x9B, 0x8E, 0x4C, 0x4F, @@ -4782,7 +4950,7 @@ public static partial class Apis 0x06, 0xB2, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4794,7 +4962,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x60, 0x38, 0x40, 0xD9, 0x7F, 0x29, 0x49, 0x4A, @@ -4806,7 +4974,7 @@ public static partial class Apis 0x50, 0xA4, 0x42 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4818,7 +4986,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDA, 0x4C, 0xA1, 0xC9, 0x39, 0xC3, 0x0B, 0x46, @@ -4830,7 +4998,7 @@ public static partial class Apis 0xFA, 0xBE, 0x91 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4842,7 +5010,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0B, 0x79, 0x97, 0x36, 0x3B, 0x22, 0x4E, 0x48, @@ -4854,7 +5022,7 @@ public static partial class Apis 0x18, 0xF1, 0x7A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4866,7 +5034,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE4, 0x13, 0x8C, 0xCB, 0xB5, 0x62, 0x96, 0x4C, @@ -4878,7 +5046,7 @@ public static partial class Apis 0xE3, 0x9C, 0x76 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4890,7 +5058,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x98, 0xB8, 0xC8, 0xB5, 0x74, 0x00, 0x9F, 0x45, @@ -4902,7 +5070,7 @@ public static partial class Apis 0x51, 0xEA, 0x14 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4914,7 +5082,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x45, 0xC6, 0x2E, 0x12, 0x7E, 0xCD, 0xD8, 0x44, @@ -4926,7 +5094,7 @@ public static partial class Apis 0xC3, 0xB5, 0x0F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4938,7 +5106,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x59, 0x29, 0x01, 0xFB, 0xF6, 0xF4, 0xD7, 0x44, @@ -4950,7 +5118,7 @@ public static partial class Apis 0xA9, 0xDB, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4962,7 +5130,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0C, 0xB2, 0x49, 0xD0, 0xD0, 0x5D, 0xFE, 0x44, @@ -4974,7 +5142,7 @@ public static partial class Apis 0xE6, 0xD0, 0x80 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -4986,7 +5154,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x59, 0x29, 0x01, 0x03, 0xF6, 0xF4, 0xD7, 0x44, @@ -4998,7 +5166,7 @@ public static partial class Apis 0xA9, 0xDB, 0x57 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5010,7 +5178,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0C, 0xB2, 0x49, 0x12, 0xD0, 0x5D, 0xFE, 0x44, @@ -5022,7 +5190,7 @@ public static partial class Apis 0xE6, 0xD0, 0x80 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5034,7 +5202,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xD7, 0xD3, 0xDC, 0xD4, 0xC2, 0xB4, 0xD9, 0x47, @@ -5046,7 +5214,7 @@ public static partial class Apis 0x96, 0xA4, 0xA3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5058,7 +5226,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x35, 0x19, 0x5C, 0x5C, 0x35, 0x02, 0x34, 0x44, @@ -5070,7 +5238,7 @@ public static partial class Apis 0xEC, 0x39, 0xC6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5082,7 +5250,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8C, 0x66, 0x10, 0x00, 0x01, 0x08, 0xA6, 0x4D, @@ -5094,7 +5262,7 @@ public static partial class Apis 0xB6, 0xD2, 0x8F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5106,7 +5274,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x26, 0x82, 0x10, 0x00, 0x41, 0xEE, 0xA2, 0x44, @@ -5118,7 +5286,7 @@ public static partial class Apis 0xB1, 0xD2, 0xCD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5130,7 +5298,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7A, 0x13, 0x05, 0x58, 0x48, 0xE3, 0x7C, 0x4F, @@ -5142,7 +5310,7 @@ public static partial class Apis 0x5A, 0x05, 0x99 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5154,7 +5322,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0E, 0xFE, 0xF2, 0x4F, 0x4A, 0xE7, 0x71, 0x4B, @@ -5166,7 +5334,7 @@ public static partial class Apis 0x67, 0x07, 0xBA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5178,7 +5346,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1E, 0x5F, 0x80, 0x02, 0xAA, 0xD5, 0x5B, 0x41, @@ -5190,7 +5358,7 @@ public static partial class Apis 0xA9, 0x88, 0xA6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5202,7 +5370,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x2B, 0xE6, 0xB5, 0x2D, 0x67, 0x0D, 0x5F, 0x49, @@ -5214,7 +5382,7 @@ public static partial class Apis 0x86, 0x47, 0xAC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5226,7 +5394,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCC, 0xAF, 0x59, 0x4B, 0xC3, 0xB8, 0x8A, 0x40, @@ -5238,7 +5406,7 @@ public static partial class Apis 0xB6, 0xFD, 0xA7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5250,7 +5418,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB9, 0xAF, 0xEB, 0xB5, 0x3E, 0x25, 0x72, 0x4A, @@ -5262,7 +5430,7 @@ public static partial class Apis 0x68, 0x56, 0x83 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5274,7 +5442,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDF, 0x24, 0xB6, 0x72, 0x11, 0xAE, 0x48, 0x49, @@ -5286,7 +5454,7 @@ public static partial class Apis 0x82, 0x94, 0x19 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5298,7 +5466,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4E, 0xE1, 0x65, 0x17, 0xD4, 0x1B, 0x2E, 0x46, @@ -5310,7 +5478,7 @@ public static partial class Apis 0x26, 0x2A, 0xC6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5322,7 +5490,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x9A, 0x0D, 0xB9, 0x01, 0x09, 0x82, 0xF7, 0x47, @@ -5334,7 +5502,7 @@ public static partial class Apis 0xF5, 0x0C, 0xED - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5346,7 +5514,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x93, 0x1F, 0xC2, 0x22, 0xDB, 0x7D, 0x1C, 0x41, @@ -5358,7 +5526,7 @@ public static partial class Apis 0x06, 0x4A, 0xBC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5370,7 +5538,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x30, 0x9A, 0xE7, 0xE7, 0x2C, 0x4F, 0xAB, 0x4F, @@ -5382,7 +5550,7 @@ public static partial class Apis 0x6B, 0xBE, 0xBE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5394,7 +5562,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8C, 0x2C, 0x82, 0xED, 0xBE, 0xD6, 0x01, 0x43, @@ -5406,7 +5574,7 @@ public static partial class Apis 0xBA, 0xD2, 0x8F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5418,7 +5586,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x53, 0xE7, 0x12, 0x7F, 0x71, 0xFC, 0xD7, 0x43, @@ -5430,7 +5598,7 @@ public static partial class Apis 0x77, 0xAB, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5442,7 +5610,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xDE, 0xD1, 0x68, 0x6D, 0x32, 0xD4, 0x0F, 0x4B, @@ -5454,7 +5622,7 @@ public static partial class Apis 0xA9, 0xBD, 0xA7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5466,7 +5634,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC2, 0xDC, 0x94, 0xAA, 0xB0, 0xB8, 0x98, 0x48, @@ -5478,7 +5646,7 @@ public static partial class Apis 0xD7, 0x43, 0x93 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5490,7 +5658,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6C, 0x2A, 0x6C, 0x07, 0x8F, 0xF7, 0x46, 0x4C, @@ -5502,7 +5670,7 @@ public static partial class Apis 0x08, 0x76, 0xEA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5514,7 +5682,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x93, 0x07, 0x07, 0x41, 0xE4, 0x59, 0x9A, 0x47, @@ -5526,7 +5694,7 @@ public static partial class Apis 0x2E, 0xF5, 0xFC - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5538,7 +5706,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE7, 0x37, 0xC0, 0x73, 0xD9, 0xE5, 0x54, 0x49, @@ -5550,7 +5718,7 @@ public static partial class Apis 0x6E, 0x57, 0x68 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5562,7 +5730,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5D, 0x34, 0x2E, 0xB9, 0x2D, 0xF5, 0xF3, 0x41, @@ -5574,7 +5742,7 @@ public static partial class Apis 0x72, 0xE3, 0xB9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5586,7 +5754,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x76, 0xDC, 0x95, 0xAF, 0xB2, 0x16, 0xF4, 0x47, @@ -5598,7 +5766,7 @@ public static partial class Apis 0x66, 0x93, 0xE7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5610,7 +5778,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x67, 0xA2, 0x47, 0x74, 0x15, 0x00, 0xC8, 0x42, @@ -5622,7 +5790,7 @@ public static partial class Apis 0xC6, 0x83, 0x61 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5634,7 +5802,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1F, 0x07, 0x89, 0x8C, 0x2E, 0x45, 0x95, 0x4E, @@ -5646,7 +5814,7 @@ public static partial class Apis 0x62, 0x71, 0x72 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5658,7 +5826,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3A, 0xB9, 0x67, 0x17, 0x21, 0xB0, 0xEA, 0x44, @@ -5670,7 +5838,7 @@ public static partial class Apis 0xF4, 0xF7, 0x68 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5682,7 +5850,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0xDF, 0x6E, 0xBD, 0x90, 0x28, 0x2F, 0x48, @@ -5694,7 +5862,7 @@ public static partial class Apis 0xA1, 0xCF, 0x8D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5706,7 +5874,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4B, 0x90, 0xB1, 0x50, 0x8F, 0xF2, 0x74, 0x45, @@ -5718,7 +5886,7 @@ public static partial class Apis 0x2C, 0x69, 0xE9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5730,7 +5898,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xF0, 0x66, 0xF5, 0x3F, 0x6B, 0x6E, 0xD4, 0x49, @@ -5742,7 +5910,7 @@ public static partial class Apis 0x69, 0x2C, 0x62 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5754,7 +5922,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x88, 0x2F, 0x6F, 0x35, 0xA6, 0x05, 0x28, 0x47, @@ -5766,7 +5934,7 @@ public static partial class Apis 0x04, 0xD8, 0x38 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5778,7 +5946,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBC, 0x3A, 0x58, 0x1D, 0x0E, 0x8A, 0x57, 0x46, @@ -5790,7 +5958,7 @@ public static partial class Apis 0x58, 0xFB, 0x4B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5802,7 +5970,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7C, 0x34, 0x66, 0x9F, 0xC4, 0x60, 0x4D, 0x4C, @@ -5814,7 +5982,7 @@ public static partial class Apis 0x85, 0xF6, 0x07 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5826,7 +5994,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6F, 0x23, 0x73, 0xE5, 0xB1, 0x55, 0xDA, 0x4E, @@ -5838,7 +6006,7 @@ public static partial class Apis 0x02, 0x90, 0xD3 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5850,7 +6018,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3B, 0x7D, 0x55, 0x32, 0xDC, 0x69, 0x95, 0x4F, @@ -5862,7 +6030,7 @@ public static partial class Apis 0x2F, 0x61, 0x59 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5874,7 +6042,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFC, 0x97, 0x27, 0xA0, 0xAE, 0xC4, 0x8C, 0x41, @@ -5886,7 +6054,7 @@ public static partial class Apis 0xEA, 0xD2, 0xA1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5898,7 +6066,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x39, 0xCA, 0x92, 0x36, 0x82, 0xE0, 0x50, 0x43, @@ -5910,7 +6078,7 @@ public static partial class Apis 0x08, 0x3C, 0xD5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5922,7 +6090,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x13, 0x6D, 0x03, 0xFF, 0x4B, 0x5D, 0xDD, 0x46, @@ -5934,7 +6102,7 @@ public static partial class Apis 0xD9, 0xFE, 0x4F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5946,7 +6114,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA6, 0xA4, 0xE7, 0x0C, 0xE8, 0x03, 0x60, 0x4A, @@ -5958,7 +6126,7 @@ public static partial class Apis 0x2E, 0xE7, 0xDA - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5970,7 +6138,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFD, 0xF2, 0xE3, 0x68, 0xAE, 0x31, 0x41, 0x44, @@ -5982,7 +6150,7 @@ public static partial class Apis 0x52, 0x5F, 0x90 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -5994,7 +6162,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xFA, 0xB2, 0xBF, 0xAA, 0x1E, 0x3E, 0x8F, 0x4A, @@ -6006,7 +6174,7 @@ public static partial class Apis 0x94, 0xEA, 0x23 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6018,7 +6186,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x19, 0x97, 0x87, 0x31, 0x51, 0xE7, 0xF8, 0x4D, @@ -6030,7 +6198,7 @@ public static partial class Apis 0x77, 0x04, 0xED - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6042,7 +6210,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x36, 0x5F, 0x0B, 0xF9, 0x7B, 0x36, 0x2A, 0x40, @@ -6054,7 +6222,7 @@ public static partial class Apis 0x9D, 0x8F, 0x62 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6066,7 +6234,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEB, 0xE3, 0x3C, 0xE2, 0x08, 0x56, 0x83, 0x4E, @@ -6078,7 +6246,7 @@ public static partial class Apis 0x7E, 0x51, 0xD7 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6090,7 +6258,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB7, 0x0B, 0x7A, 0x87, 0x13, 0xA3, 0x91, 0x44, @@ -6102,7 +6270,7 @@ public static partial class Apis 0x94, 0xF5, 0x20 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6114,7 +6282,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x49, 0xE7, 0x03, 0x8A, 0x2E, 0x67, 0x6E, 0x44, @@ -6126,7 +6294,7 @@ public static partial class Apis 0x33, 0xB6, 0xFF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6138,7 +6306,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3B, 0xE6, 0xD3, 0xF5, 0x0F, 0xCB, 0x28, 0x46, @@ -6150,7 +6318,7 @@ public static partial class Apis 0xBE, 0x36, 0xB1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6162,7 +6330,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5F, 0x1E, 0x67, 0x16, 0xE6, 0x0C, 0xC4, 0x4C, @@ -6174,7 +6342,7 @@ public static partial class Apis 0x01, 0x8A, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6186,7 +6354,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0C, 0x36, 0x40, 0xFB, 0x7E, 0x54, 0x56, 0x49, @@ -6198,7 +6366,7 @@ public static partial class Apis 0x59, 0xBA, 0x66 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6210,7 +6378,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC6, 0x35, 0xEE, 0xA6, 0xEC, 0x87, 0xDF, 0x47, @@ -6222,7 +6390,7 @@ public static partial class Apis 0x84, 0x0C, 0x82 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6234,7 +6402,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0xDF, 0x4E, 0xD9, 0xE5, 0xEF, 0x0D, 0x4F, @@ -6246,7 +6414,7 @@ public static partial class Apis 0x30, 0x00, 0xB1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6258,7 +6426,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x00, 0x84, 0xB7, 0x1A, 0xA3, 0xB5, 0x91, 0x4D, @@ -6270,7 +6438,7 @@ public static partial class Apis 0x49, 0x9B, 0xE6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6282,7 +6450,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCA, 0x88, 0x6C, 0x27, 0x33, 0x75, 0x86, 0x4A, @@ -6294,7 +6462,7 @@ public static partial class Apis 0x80, 0xD4, 0x84 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6306,7 +6474,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBD, 0x8B, 0x68, 0xFD, 0xED, 0x31, 0xB7, 0x4D, @@ -6318,7 +6486,7 @@ public static partial class Apis 0xD3, 0x83, 0x67 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6330,7 +6498,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3F, 0xFC, 0xDD, 0xAC, 0xEC, 0x85, 0xBC, 0x41, @@ -6342,7 +6510,7 @@ public static partial class Apis 0xE4, 0xDB, 0x05 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6354,7 +6522,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x79, 0x5E, 0xE4, 0x3A, 0xBC, 0x40, 0x01, 0x44, @@ -6366,7 +6534,7 @@ public static partial class Apis 0x6E, 0x6A, 0xFE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6378,7 +6546,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3D, 0xDE, 0x38, 0x24, 0xD9, 0x94, 0xE8, 0x4B, @@ -6390,7 +6558,31 @@ public static partial class Apis 0x57, 0x5E, 0x75 - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICHeifHDRMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xA2, 0x35, 0x31, 0xB8, + 0x7E, 0x8E, + 0x5E, 0x48, + 0xA5, + 0x33, + 0xF9, + 0x36, + 0x21, + 0xDD, + 0x93, + 0xC8 + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6402,7 +6594,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x11, 0x99, 0x6F, 0x07, 0x48, 0xA3, 0x5C, 0x46, @@ -6414,7 +6606,7 @@ public static partial class Apis 0xF2, 0xD3, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6426,7 +6618,7 @@ public static partial class Apis [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x03, 0x0B, 0xA1, 0x85, 0xF6, 0xC9, 0x9F, 0x43, @@ -6438,7 +6630,103 @@ public static partial class Apis 0x67, 0x80, 0x7C - }; + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegXLAnimMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xB0, 0x6E, 0x8B, 0xBF, + 0xE2, 0x37, + 0xD8, 0x4E, + 0x82, + 0x89, + 0xBE, + 0x9A, + 0xE3, + 0x1D, + 0x9F, + 0x03 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegXLAnimMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0x45, 0x13, 0xD0, 0x39, + 0x2B, 0x43, + 0xE6, 0x44, + 0xAF, + 0xD6, + 0xF6, + 0x06, + 0xD2, + 0x0A, + 0x55, + 0x71 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegXLAnimFrameMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xA8, 0x50, 0xDF, 0x9C, + 0x70, 0x87, + 0xE6, 0x4F, + 0xAE, + 0xF2, + 0xD0, + 0x6E, + 0x2C, + 0x01, + 0x74, + 0x4F + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegXLAnimFrameMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xA8, 0x58, 0xCE, 0xD1, + 0xE0, 0x06, + 0x6F, 0x4B, + 0x8F, + 0xC1, + 0x57, + 0x75, + 0x60, + 0xBD, + 0x5A, + 0xD9 + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); @@ -6660,6 +6948,11 @@ public static partial class Apis public const WICHeifHdrProperties WICHeifHdrCustomVideoPrimaries = WICHeifHdrProperties.CustomVideoPrimaries; public const WICWebpAnimProperties WICWebpAnimLoopCount = WICWebpAnimProperties.LoopCount; public const WICWebpAnmfProperties WICWebpAnmfFrameDuration = WICWebpAnmfProperties.FrameDuration; + public const WICJpegXLAnimProperties WICJpegXLAnimLoopCount = WICJpegXLAnimProperties.LoopCount; + public const WICJpegXLAnimProperties WICJpegXLAnimFrameTicksPerSecondNumerator = WICJpegXLAnimProperties.FrameTicksPerSecondNumerator; + public const WICJpegXLAnimProperties WICJpegXLAnimFrameTicksPerSecondDenominator = WICJpegXLAnimProperties.FrameTicksPerSecondDenominator; + public const WICJpegXLAnimFrameProperties WICJpegXLAnimFrameDurationInTicks = WICJpegXLAnimFrameProperties.DurationInTicks; + public const WICJpegXLAnimFrameProperties WICJpegXLAnimFrameName = WICJpegXLAnimFrameProperties.Name; public const WICSectionAccessLevel WICSectionAccessLevelRead = WICSectionAccessLevel.Read; public const WICSectionAccessLevel WICSectionAccessLevelReadWrite = WICSectionAccessLevel.ReadWrite; public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationUnspecified = WICPixelFormatNumericRepresentation.Unspecified; @@ -6697,6 +6990,10 @@ public static partial class Apis public const WICPngFilterOption WICPngFilterAverage = WICPngFilterOption.Average; public const WICPngFilterOption WICPngFilterPaeth = WICPngFilterOption.Paeth; public const WICPngFilterOption WICPngFilterAdaptive = WICPngFilterOption.Adaptive; + public const WICHeifCompressionOption WICHeifCompressionDontCare = WICHeifCompressionOption.WICHeifCompressionDontCare; + public const WICHeifCompressionOption WICHeifCompressionNone = WICHeifCompressionOption.WICHeifCompressionNone; + public const WICHeifCompressionOption WICHeifCompressionHEVC = WICHeifCompressionOption.WICHeifCompressionHEVC; + public const WICHeifCompressionOption WICHeifCompressionAV1 = WICHeifCompressionOption.WICHeifCompressionAV1; public const WICNamedWhitePoint WICWhitePointDefault = WICNamedWhitePoint.Default; public const WICNamedWhitePoint WICWhitePointDaylight = WICNamedWhitePoint.Daylight; public const WICNamedWhitePoint WICWhitePointCloudy = WICNamedWhitePoint.Cloudy; diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Enums.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Enums.cs index 454d89e..8858a59 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Enums.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Enums.cs @@ -698,6 +698,33 @@ public enum WICWebpAnmfProperties FrameDuration = 1, } +/// +/// WICJpegXLAnimProperties +public enum WICJpegXLAnimProperties +{ + /// + /// WICJpegXLAnimLoopCount + LoopCount = 1, + /// + /// WICJpegXLAnimFrameTicksPerSecondNumerator + FrameTicksPerSecondNumerator = 2, + /// + /// WICJpegXLAnimFrameTicksPerSecondDenominator + FrameTicksPerSecondDenominator = 3, +} + +/// +/// WICJpegXLAnimFrameProperties +public enum WICJpegXLAnimFrameProperties +{ + /// + /// WICJpegXLAnimFrameDurationInTicks + DurationInTicks = 1, + /// + /// WICJpegXLAnimFrameName + Name = 2, +} + /// /// WICSectionAccessLevel public enum WICSectionAccessLevel @@ -863,6 +890,24 @@ public enum WICPngFilterOption Adaptive = 6, } +/// +/// WICHeifCompressionOption +public enum WICHeifCompressionOption +{ + /// + /// WICHeifCompressionDontCare + WICHeifCompressionDontCare = 0, + /// + /// WICHeifCompressionNone + WICHeifCompressionNone = 1, + /// + /// WICHeifCompressionHEVC + WICHeifCompressionHEVC = 2, + /// + /// WICHeifCompressionAV1 + WICHeifCompressionAV1 = 3, +} + /// /// WICNamedWhitePoint public enum WICNamedWhitePoint diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmap.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmap.cs index b77b8b3..0b17ce3 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmap.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmap.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmap : IWICBitmap.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x21, 0x01, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmap : IWICBitmap.Interface, INativeGuid 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapClipper.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapClipper.cs index 7bc64d0..c5be19b 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapClipper.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapClipper.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapClipper : IWICBitmapClipper.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x03, 0xCF, 0xFB, 0xE4, 0x3D, 0x22, 0x81, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapClipper : IWICBitmapClipper.Interface, IN 0x6D, 0xD1, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecInfo.cs index 9bff4ed..23a62a3 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapCodecInfo : IWICBitmapCodecInfo.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xC4, 0x44, 0x7A, 0xE8, 0x6E, 0xB7, 0x47, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapCodecInfo : IWICBitmapCodecInfo.Interface 0x2A, 0x27, 0x14 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecProgressNotification.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecProgressNotification.cs index 702da65..7a9d153 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecProgressNotification.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapCodecProgressNotification.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapCodecProgressNotification : IWICBitmapCod [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4E, 0x02, 0xC1, 0x64, 0xCF, 0xC3, 0x62, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapCodecProgressNotification : IWICBitmapCod 0x1C, 0x46, 0xD9 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoder.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoder.cs index d2d707c..e4d85cb 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoder.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapDecoder : IWICBitmapDecoder.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xE7, 0xE9, 0xDD, 0x9E, 0xEE, 0x8D, 0xEA, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapDecoder : IWICBitmapDecoder.Interface, IN 0xED, 0x44, 0xBF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoderInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoderInfo.cs index f647eec..55c78a5 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoderInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapDecoderInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapDecoderInfo : IWICBitmapDecoderInfo.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x7F, 0x00, 0xCD, 0xD8, 0x8F, 0xD0, 0x91, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapDecoderInfo : IWICBitmapDecoderInfo.Inter 0xF0, 0xE4, 0xB5 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoder.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoder.cs index 5d99ac3..ec7dd9c 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoder.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapEncoder : IWICBitmapEncoder.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x03, 0x01, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapEncoder : IWICBitmapEncoder.Interface, IN 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoderInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoderInfo.cs index ca22b61..23c0e56 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoderInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapEncoderInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapEncoderInfo : IWICBitmapEncoderInfo.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xEE, 0xB4, 0xC9, 0x94, 0x9F, 0xA0, 0x92, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapEncoderInfo : IWICBitmapEncoderInfo.Inter 0x7E, 0x76, 0xFB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFlipRotator.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFlipRotator.cs index 3b1d5e9..11642d1 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFlipRotator.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFlipRotator.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapFlipRotator : IWICBitmapFlipRotator.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4F, 0x83, 0x09, 0x50, 0x6A, 0x2D, 0xCE, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapFlipRotator : IWICBitmapFlipRotator.Inter 0xF7, 0xA7, 0x82 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameDecode.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameDecode.cs index 3bcda1d..c096640 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameDecode.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameDecode.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapFrameDecode : IWICBitmapFrameDecode.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1B, 0x81, 0x16, 0x3B, 0x43, 0x6A, 0xC9, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapFrameDecode : IWICBitmapFrameDecode.Inter 0x13, 0xB9, 0x40 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameEncode.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameEncode.cs index cc113b1..67da4cf 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameEncode.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapFrameEncode.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapFrameEncode : IWICBitmapFrameEncode.Inter [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x05, 0x01, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapFrameEncode : IWICBitmapFrameEncode.Inter 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapLock.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapLock.cs index 86cdfd6..80191dd 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapLock.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapLock.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapLock : IWICBitmapLock.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x23, 0x01, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapLock : IWICBitmapLock.Interface, INativeG 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapScaler.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapScaler.cs index 7d2992e..a01e173 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapScaler.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapScaler.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapScaler : IWICBitmapScaler.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0x03, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapScaler : IWICBitmapScaler.Interface, INat 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSource.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSource.cs index ba82c5c..71c7ae5 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSource.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSource.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapSource : IWICBitmapSource.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x20, 0x01, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapSource : IWICBitmapSource.Interface, INat 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform.cs index 5b9dab9..61cb000 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICBitmapSourceTransform : IWICBitmapSourceTransfo [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1B, 0x81, 0x16, 0x3B, 0x43, 0x6A, 0xC9, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IWICBitmapSourceTransform : IWICBitmapSourceTransfo 0x13, 0xB9, 0x40 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform2.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform2.cs new file mode 100644 index 0000000..715a88c --- /dev/null +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICBitmapSourceTransform2.cs @@ -0,0 +1,119 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Imaging; + +/// +/// IWICBitmapSourceTransform2 +[Guid("c3373fdf-6d39-4e5f-8e79-bf40c0b7ed77")] +[NativeTypeName("struct IWICBitmapSourceTransform2 : IWICBitmapSourceTransform")] +[NativeInheritance("IWICBitmapSourceTransform")] +public unsafe partial struct IWICBitmapSourceTransform2 : IWICBitmapSourceTransform2.Interface, INativeGuid +{ + public static ref readonly Guid IID_IWICBitmapSourceTransform2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xDF, 0x3F, 0x37, 0xC3, + 0x39, 0x6D, + 0x5F, 0x4E, + 0x8E, + 0x79, + 0xBF, + 0x40, + 0xC0, + 0xB7, + 0xED, + 0x77 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapSourceTransform2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CopyPixels(System.Drawing.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this), prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetClosestSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetClosestPixelFormat(Guid* pguidDstFormat) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this), pguidDstFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult DoesSupportTransform(WICBitmapTransformOptions dstTransform, Bool32* pfIsSupported) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[6]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this), dstTransform, pfIsSupported); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetColorContextsForPixelFormat(Guid* pPixelFormat, uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[7]))((IWICBitmapSourceTransform2*)Unsafe.AsPointer(ref this), pPixelFormat, cCount, ppIColorContexts, pcActualCount); + } + + public interface Interface : IWICBitmapSourceTransform.Interface + { + [VtblIndex(7)] + HResult GetColorContextsForPixelFormat(Guid* pPixelFormat, uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount); + } +} + diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorContext.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorContext.cs index 6b7839f..ff32d10 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorContext.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorContext.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICColorContext : IWICColorContext.Interface, INat [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x02, 0x3A, 0x61, 0x3C, 0xB2, 0x34, 0xEA, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IWICColorContext : IWICColorContext.Interface, INat 0xC6, 0xFD, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorTransform.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorTransform.cs index 48e8ca2..320a44b 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorTransform.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICColorTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICColorTransform : IWICColorTransform.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4F, 0x03, 0x6F, 0xB6, 0xE2, 0xD0, 0xAB, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IWICColorTransform : IWICColorTransform.Interface, 0x32, 0x1A, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentFactory.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentFactory.cs index cc82f9b..29f99c4 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentFactory.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICComponentFactory : IWICComponentFactory.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x3A, 0x0C, 0x2D, 0x41, 0x50, 0x96, 0xFA, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IWICComponentFactory : IWICComponentFactory.Interfa 0xC8, 0xE8, 0xFB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentInfo.cs index 28bedb8..37fe394 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICComponentInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICComponentInfo : IWICComponentInfo.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x0A, 0x3F, 0xBC, 0x23, 0x8B, 0x69, 0x57, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICComponentInfo : IWICComponentInfo.Interface, IN 0x67, 0x13, 0x34 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsDecoder.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsDecoder.cs index 14d3230..5eb1e8b 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsDecoder.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsDecoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICDdsDecoder : IWICDdsDecoder.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x37, 0xD5, 0x9C, 0x40, 0x32, 0x85, 0xCB, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IWICDdsDecoder : IWICDdsDecoder.Interface, INativeG 0xDF, 0x4E, 0x9C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsEncoder.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsEncoder.cs index 733cbfa..6ad4b96 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsEncoder.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsEncoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICDdsEncoder : IWICDdsEncoder.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x4C, 0xDB, 0xAC, 0x5C, 0x7E, 0x40, 0xB3, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IWICDdsEncoder : IWICDdsEncoder.Interface, INativeG 0xCD, 0x67, 0x32 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsFrameDecode.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsFrameDecode.cs index c4862d2..3f7c825 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsFrameDecode.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDdsFrameDecode.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICDdsFrameDecode : IWICDdsFrameDecode.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x61, 0x0C, 0x4C, 0x3D, 0xA4, 0x18, 0xE4, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IWICDdsFrameDecode : IWICDdsFrameDecode.Interface, 0xC9, 0xF4, 0x64 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRaw.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRaw.cs index e91f01c..b4ecabf 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRaw.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRaw.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICDevelopRaw : IWICDevelopRaw.Interface, INativeG [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x44, 0x5E, 0xEC, 0xFB, 0xBE, 0xF7, 0x65, 0x4B, @@ -33,7 +33,7 @@ public unsafe partial struct IWICDevelopRaw : IWICDevelopRaw.Interface, INativeG 0xEF, 0x02, 0x6D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRawNotificationCallback.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRawNotificationCallback.cs index cd3e194..82c9aad 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRawNotificationCallback.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDevelopRawNotificationCallback.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICDevelopRawNotificationCallback : IWICDevelopRaw [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0x5A, 0xC7, 0x95, 0x8C, 0x3E, 0xC2, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IWICDevelopRawNotificationCallback : IWICDevelopRaw 0x51, 0xE5, 0x9B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDisplayAdaptationControl.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDisplayAdaptationControl.cs new file mode 100644 index 0000000..b224198 --- /dev/null +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICDisplayAdaptationControl.cs @@ -0,0 +1,109 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +namespace Win32.Graphics.Imaging; + +/// +/// IWICDisplayAdaptationControl +[Guid("de9d91d2-70b4-4f41-836c-25fcd39626d3")] +[NativeTypeName("struct IWICDisplayAdaptationControl : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICDisplayAdaptationControl : IWICDisplayAdaptationControl.Interface, INativeGuid +{ + public static ref readonly Guid IID_IWICDisplayAdaptationControl + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = [ + 0xD2, 0x91, 0x9D, 0xDE, + 0xB4, 0x70, + 0x41, 0x4F, + 0x83, + 0x6C, + 0x25, + 0xFC, + 0xD3, + 0x96, + 0x26, + 0xD3 + ]; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICDisplayAdaptationControl)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[0]))((IWICDisplayAdaptationControl*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[1]))((IWICDisplayAdaptationControl*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[2]))((IWICDisplayAdaptationControl*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult DoesSupportChangingMaxLuminance(Guid* pguidDstFormat, Bool32* pfIsSupported) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[3]))((IWICDisplayAdaptationControl*)Unsafe.AsPointer(ref this), pguidDstFormat, pfIsSupported); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetDisplayMaxLuminance(float fLuminanceInNits) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[4]))((IWICDisplayAdaptationControl*)Unsafe.AsPointer(ref this), fLuminanceInNits); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetDisplayMaxLuminance(float* pfLuminanceInNits) + { + return ((delegate* unmanaged[MemberFunction])(lpVtbl[5]))((IWICDisplayAdaptationControl*)Unsafe.AsPointer(ref this), pfLuminanceInNits); + } + + public interface Interface : IUnknown.Interface + { + [VtblIndex(3)] + HResult DoesSupportChangingMaxLuminance(Guid* pguidDstFormat, Bool32* pfIsSupported); + + [VtblIndex(4)] + HResult SetDisplayMaxLuminance(float fLuminanceInNits); + + [VtblIndex(5)] + HResult GetDisplayMaxLuminance(float* pfLuminanceInNits); + } +} + diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICEnumMetadataItem.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICEnumMetadataItem.cs index a61f466..3c1adb2 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICEnumMetadataItem.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICEnumMetadataItem.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICEnumMetadataItem : IWICEnumMetadataItem.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6D, 0xB4, 0x2B, 0xDC, 0x07, 0x3F, 0x1E, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICEnumMetadataItem : IWICEnumMetadataItem.Interfa 0xED, 0xBB, 0x33 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFastMetadataEncoder.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFastMetadataEncoder.cs index 1112f56..f3fdf39 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFastMetadataEncoder.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFastMetadataEncoder.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICFastMetadataEncoder : IWICFastMetadataEncoder.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x09, 0x2C, 0x4E, 0xB8, 0xC9, 0x78, 0xC4, 0x4A, @@ -33,7 +33,7 @@ public unsafe partial struct IWICFastMetadataEncoder : IWICFastMetadataEncoder.I 0x66, 0x3A, 0x2F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverter.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverter.cs index 35387de..84d2ec7 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverter.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverter.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICFormatConverter : IWICFormatConverter.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0x03, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICFormatConverter : IWICFormatConverter.Interface 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverterInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverterInfo.cs index 4aa7aa6..561b33f 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverterInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICFormatConverterInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICFormatConverterInfo : IWICFormatConverterInfo.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x65, 0xFB, 0x34, 0x9F, 0xF4, 0x13, 0x15, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IWICFormatConverterInfo : IWICFormatConverterInfo.I 0xE5, 0x3D, 0x9F - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICImagingFactory.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICImagingFactory.cs index 9b9f7ff..638e0d8 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICImagingFactory.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICImagingFactory.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICImagingFactory : IWICImagingFactory.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA9, 0xC8, 0x5E, 0xEC, 0x95, 0xC3, 0x14, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICImagingFactory : IWICImagingFactory.Interface, 0x35, 0xFF, 0x70 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameDecode.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameDecode.cs index 4cc40c6..6caa95c 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameDecode.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameDecode.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICJpegFrameDecode : IWICJpegFrameDecode.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6E, 0xF6, 0x39, 0x89, 0x6A, 0xC4, 0x21, 0x4C, @@ -33,7 +33,7 @@ public unsafe partial struct IWICJpegFrameDecode : IWICJpegFrameDecode.Interface 0xCE, 0x16, 0x79 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameEncode.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameEncode.cs index 9c779a6..beb53ce 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameEncode.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICJpegFrameEncode.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICJpegFrameEncode : IWICJpegFrameEncode.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1F, 0x60, 0x0C, 0x2F, 0xC6, 0xD2, 0x8C, 0x46, @@ -33,7 +33,7 @@ public unsafe partial struct IWICJpegFrameEncode : IWICJpegFrameEncode.Interface 0x98, 0x3E, 0xD1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockReader.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockReader.cs index 0fa197a..7dcf17f 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockReader.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockReader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataBlockReader : IWICMetadataBlockReader.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x8D, 0x2A, 0xAA, 0xFE, 0xF3, 0xB3, 0xE4, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataBlockReader : IWICMetadataBlockReader.I 0x0A, 0x1A, 0xE1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockWriter.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockWriter.cs index 6d6f72e..6c86cef 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockWriter.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataBlockWriter.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataBlockWriter : IWICMetadataBlockWriter.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x76, 0x96, 0xFB, 0x08, 0x44, 0xB4, 0xE8, 0x41, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataBlockWriter : IWICMetadataBlockWriter.I 0x42, 0xBF, 0xF1 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataHandlerInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataHandlerInfo.cs index 8dd904f..33ff14c 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataHandlerInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataHandlerInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataHandlerInfo : IWICMetadataHandlerInfo.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBF, 0x58, 0xA9, 0xAB, 0x72, 0xC6, 0xD1, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataHandlerInfo : IWICMetadataHandlerInfo.I 0xE6, 0x82, 0xC2 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryReader.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryReader.cs index 1d26efa..7d0d3be 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryReader.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryReader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataQueryReader : IWICMetadataQueryReader.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x68, 0x96, 0x98, 0x30, 0xC9, 0xE1, 0x97, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataQueryReader : IWICMetadataQueryReader.I 0xB8, 0x08, 0xDF - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryWriter.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryWriter.cs index b9ef29a..7a19ebc 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryWriter.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataQueryWriter.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataQueryWriter : IWICMetadataQueryWriter.I [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x1A, 0x79, 0x21, 0xA7, 0xEF, 0x0D, 0x06, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataQueryWriter : IWICMetadataQueryWriter.I 0x1D, 0xB1, 0x0B - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReader.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReader.cs index b625db0..81ce685 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReader.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReader.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataReader : IWICMetadataReader.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x99, 0xFE, 0x04, 0x92, 0xFC, 0xD8, 0xD5, 0x4F, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataReader : IWICMetadataReader.Interface, 0x67, 0xA8, 0x99 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReaderInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReaderInfo.cs index 0de7de0..8580b3a 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReaderInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataReaderInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataReaderInfo : IWICMetadataReaderInfo.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x5B, 0x1F, 0xBF, 0xEE, 0xC1, 0x07, 0x47, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataReaderInfo : IWICMetadataReaderInfo.Int 0x78, 0xA8, 0x04 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriter.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriter.cs index 054a538..a3dbdc4 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriter.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriter.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataWriter : IWICMetadataWriter.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x16, 0x6E, 0x83, 0xF7, 0xE0, 0x3B, 0x0B, 0x47, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataWriter : IWICMetadataWriter.Interface, 0xEC, 0xD7, 0xDE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriterInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriterInfo.cs index 2fa9149..8c2862b 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriterInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICMetadataWriterInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICMetadataWriterInfo : IWICMetadataWriterInfo.Int [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBA, 0x3F, 0x2E, 0xB2, 0x25, 0x39, 0x23, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICMetadataWriterInfo : IWICMetadataWriterInfo.Int 0x30, 0xF2, 0x36 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPalette.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPalette.cs index f22244c..9684fea 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPalette.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPalette.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPalette : IWICPalette.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x40, 0x00, 0x00, 0x00, 0xF2, 0xA8, 0x77, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPalette : IWICPalette.Interface, INativeGuid 0x45, 0xFB, 0x94 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPersistStream.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPersistStream.cs index 89bc8ee..003e624 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPersistStream.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPersistStream.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPersistStream : IWICPersistStream.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x40, 0x50, 0x67, 0x00, 0x08, 0x69, 0xF8, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPersistStream : IWICPersistStream.Interface, IN 0xD6, 0xD9, 0xAD - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo.cs index 71de620..6b7f3dc 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPixelFormatInfo : IWICPixelFormatInfo.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x01, 0xA6, 0xED, 0xE8, 0x48, 0x3D, 0x1A, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPixelFormatInfo : IWICPixelFormatInfo.Interface 0xE8, 0x8B, 0xBE - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo2.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo2.cs index 84b0f9b..61e6539 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo2.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPixelFormatInfo2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPixelFormatInfo2 : IWICPixelFormatInfo2.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xA2, 0x33, 0xDB, 0xA9, 0x5F, 0xAF, 0xC7, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPixelFormatInfo2 : IWICPixelFormatInfo2.Interfa 0x4B, 0x5A, 0xA4 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapFrameEncode.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapFrameEncode.cs index ecc68d1..832b4db 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapFrameEncode.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapFrameEncode.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPlanarBitmapFrameEncode : IWICPlanarBitmapFrame [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xB8, 0xB7, 0x28, 0xF9, 0x21, 0x22, 0xC1, 0x40, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPlanarBitmapFrameEncode : IWICPlanarBitmapFrame 0x97, 0x4D, 0x1A - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapSourceTransform.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapSourceTransform.cs index 9c58366..8eabd7d 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapSourceTransform.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarBitmapSourceTransform.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPlanarBitmapSourceTransform : IWICPlanarBitmapS [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCE, 0x9C, 0xFF, 0x3A, 0x95, 0xBE, 0x03, 0x43, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPlanarBitmapSourceTransform : IWICPlanarBitmapS 0xF4, 0xA6, 0x13 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarFormatConverter.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarFormatConverter.cs index a00829b..7e44371 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarFormatConverter.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICPlanarFormatConverter.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICPlanarFormatConverter : IWICPlanarFormatConvert [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCB, 0xE9, 0xBE, 0xBE, 0xB0, 0x83, 0xCC, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IWICPlanarFormatConverter : IWICPlanarFormatConvert 0x5E, 0xAC, 0x96 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressCallback.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressCallback.cs index 4e1a369..0f0151c 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressCallback.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressCallback.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICProgressCallback : IWICProgressCallback.Interfa [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCD, 0xF9, 0x76, 0x47, 0x17, 0x95, 0xFA, 0x45, @@ -33,7 +33,7 @@ public unsafe partial struct IWICProgressCallback : IWICProgressCallback.Interfa 0xC5, 0xC6, 0x0C - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressiveLevelControl.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressiveLevelControl.cs index 9ae56bc..44b933a 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressiveLevelControl.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICProgressiveLevelControl.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICProgressiveLevelControl : IWICProgressiveLevelC [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x6F, 0x29, 0xAC, 0xDA, 0xA5, 0x7A, 0xBF, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IWICProgressiveLevelControl : IWICProgressiveLevelC 0x76, 0xF8, 0x91 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStream.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStream.cs index 747ef46..2e92010 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStream.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStream.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICStream : IWICStream.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x60, 0xF8, 0x5F, 0x13, 0xB7, 0x22, 0xDF, 0x4D, @@ -33,7 +33,7 @@ public unsafe partial struct IWICStream : IWICStream.Interface, INativeGuid 0x29, 0x9A, 0x43 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStreamProvider.cs b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStreamProvider.cs index 40e5400..04aa85f 100644 --- a/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStreamProvider.cs +++ b/src/Vortice.Win32.Graphics.Imaging/Generated/IWICStreamProvider.cs @@ -21,7 +21,7 @@ public unsafe partial struct IWICStreamProvider : IWICStreamProvider.Interface, [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBC, 0x94, 0x94, 0x44, 0x68, 0xB4, 0x27, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IWICStreamProvider : IWICStreamProvider.Interface, 0x1A, 0xB5, 0x05 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPO.cs b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPO.cs index e8374f8..06f4ee1 100644 --- a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPO.cs +++ b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPO.cs @@ -21,7 +21,7 @@ public unsafe partial struct IXAPO : IXAPO.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x84, 0xB9, 0x10, 0xA4, 0x39, 0x98, 0x19, 0x48, @@ -33,7 +33,7 @@ public unsafe partial struct IXAPO : IXAPO.Interface, INativeGuid 0x6B, 0x3A, 0xDB - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOHrtfParameters.cs b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOHrtfParameters.cs index e2347ef..6cc1d8c 100644 --- a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOHrtfParameters.cs +++ b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOHrtfParameters.cs @@ -21,7 +21,7 @@ public unsafe partial struct IXAPOHrtfParameters : IXAPOHrtfParameters.Interface [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0xCD, 0xB3, 0x15, 0xDE, 0xE9, 0x64, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IXAPOHrtfParameters : IXAPOHrtfParameters.Interface 0x63, 0xD4, 0x55 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOParameters.cs b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOParameters.cs index 65de42f..815b0f9 100644 --- a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOParameters.cs +++ b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAPOParameters.cs @@ -21,7 +21,7 @@ public unsafe partial struct IXAPOParameters : IXAPOParameters.Interface, INativ [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0x66, 0x5C, 0xD9, 0x26, 0xF2, 0x80, 0x9A, 0x49, @@ -33,7 +33,7 @@ public unsafe partial struct IXAPOParameters : IXAPOParameters.Interface, INativ 0x1C, 0x6D, 0x98 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2.cs b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2.cs index b68abaf..1906ff6 100644 --- a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2.cs +++ b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2.cs @@ -21,7 +21,7 @@ public unsafe partial struct IXAudio2 : IXAudio2.Interface, INativeGuid [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xCF, 0xE3, 0x02, 0x2B, 0x0B, 0x2E, 0xC3, 0x4E, @@ -33,7 +33,7 @@ public unsafe partial struct IXAudio2 : IXAudio2.Interface, INativeGuid 0xE7, 0x21, 0x0D - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2Extension.cs b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2Extension.cs index 899790a..c817eea 100644 --- a/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2Extension.cs +++ b/src/Vortice.Win32.Media.Audio.XAudio2/Generated/IXAudio2Extension.cs @@ -21,7 +21,7 @@ public unsafe partial struct IXAudio2Extension : IXAudio2Extension.Interface, IN [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = new byte[] { + ReadOnlySpan data = [ 0xBB, 0x29, 0xAC, 0x84, 0x19, 0xD6, 0xD2, 0x44, @@ -33,7 +33,7 @@ public unsafe partial struct IXAudio2Extension : IXAudio2Extension.Interface, IN 0xDF, 0x3E, 0xD6 - }; + ]; Debug.Assert(data.Length == Unsafe.SizeOf()); return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); diff --git a/src/Vortice.Win32/ComPtr.cs b/src/Vortice.Win32/ComPtr.cs index f7e6498..f827885 100644 --- a/src/Vortice.Win32/ComPtr.cs +++ b/src/Vortice.Win32/ComPtr.cs @@ -3,8 +3,6 @@ // Original source is Copyright © Microsoft. All rights reserved. using System.ComponentModel; -using System.Diagnostics; -using System.Runtime.CompilerServices; using static Win32.Apis; namespace Win32; @@ -63,7 +61,7 @@ public unsafe struct ComPtr : IDisposable /// The result of for the target type . /// This method will automatically release the target COM object pointed to by , if any. public readonly HResult As(ref ComPtr other) - where U : unmanaged, IUnknown.Interface + where U : unmanaged, IUnknown.Interface { U* ptr; HResult result = ptr_->QueryInterface(__uuidof(), (void**)&ptr); @@ -232,9 +230,7 @@ public unsafe struct ComPtr : IDisposable return ptr_; } - /// - /// Gets the address of the current instance as a raw double pointer. - /// This method is only valid when the current instance is on the stack or pinned. + /// Gets the address of the current instance as a raw double pointer. This method is only valid when the current instance is on the stack or pinned. /// /// The raw pointer to the current instance. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -243,17 +239,6 @@ public unsafe struct ComPtr : IDisposable return (T**)Unsafe.AsPointer(ref Unsafe.AsRef(in this)); } - /// - /// Gets the address of the current instance as a raw double pointer. - /// - /// The raw pointer to the input instance. - /// This method is only valid when the current instance is on the stack or pinned. - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public unsafe void** GetVoidAddressOf() - { - return (void**)Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - } - /// Gets the address of the current instance as a raw double pointer. /// The raw pointer to the current instance. [EditorBrowsable(EditorBrowsableState.Never)] @@ -270,15 +255,12 @@ public unsafe struct ComPtr : IDisposable return GetAddressOf(); } - /// - /// Releases the current COM object in use and gets the address of the instance as a void* double pointer. - /// This method is only valid when the current instance is on the stack or pinned. - /// The raw pointer to the current instance. + /// Resets the current instance by decrementing the reference count for the target COM object and setting the internal raw pointer to . + /// The updated reference count for the COM object that was in use, if any. [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void** ReleaseAndGetVoidAddressOf() + public uint Reset() { - _ = InternalRelease(); - return GetVoidAddressOf(); + return InternalRelease(); } /// @@ -295,11 +277,6 @@ public unsafe struct ComPtr : IDisposable return copy; } - /// Resets the current instance by decrementing the reference count for the target COM object and setting the internal raw pointer to . - /// The updated reference count for the COM object that was in use, if any. - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public uint Reset() => InternalRelease(); - /// Swaps the current COM object reference with that of a given instance. /// The target instance to swap with the current one. [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/Vortice.Win32/Vortice.Win32.csproj b/src/Vortice.Win32/Vortice.Win32.csproj index ce223d0..44711a7 100644 --- a/src/Vortice.Win32/Vortice.Win32.csproj +++ b/src/Vortice.Win32/Vortice.Win32.csproj @@ -3,6 +3,7 @@ net8.0;net9.0 Windows API low level bindings + true