diff --git a/Silk.NET.sln b/Silk.NET.sln index 3c1d84feb8..8c56022364 100644 --- a/Silk.NET.sln +++ b/Silk.NET.sln @@ -606,6 +606,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "OpenCL Demos", "OpenCL Demo EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloWorld", "examples\CSharp\OpenCL Demos\HelloWorld\HelloWorld.csproj", "{9CB90BB8-946F-4962-9365-A97BF5C6550A}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.OpenXR.Extensions.NV", "src\OpenXR\Extensions\Silk.NET.OpenXR.Extensions.NV\Silk.NET.OpenXR.Extensions.NV.csproj", "{34D35A41-E974-40C9-8888-3510A0F074AA}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -3687,6 +3689,18 @@ Global {9CB90BB8-946F-4962-9365-A97BF5C6550A}.Release|x64.Build.0 = Release|Any CPU {9CB90BB8-946F-4962-9365-A97BF5C6550A}.Release|x86.ActiveCfg = Release|Any CPU {9CB90BB8-946F-4962-9365-A97BF5C6550A}.Release|x86.Build.0 = Release|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Debug|x64.ActiveCfg = Debug|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Debug|x64.Build.0 = Debug|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Debug|x86.ActiveCfg = Debug|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Debug|x86.Build.0 = Debug|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Release|Any CPU.Build.0 = Release|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Release|x64.ActiveCfg = Release|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Release|x64.Build.0 = Release|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Release|x86.ActiveCfg = Release|Any CPU + {34D35A41-E974-40C9-8888-3510A0F074AA}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -3982,6 +3996,7 @@ Global {A0E20061-FFF6-4444-86E0-4519A0CA6944} = {49BC383A-D7E6-4013-93C7-371479B984CC} {FD0C9C4B-3777-4755-A87B-60FE65D92750} = {6842A2C6-5C7B-42DD-9825-0EDE91BFEBF7} {9CB90BB8-946F-4962-9365-A97BF5C6550A} = {FD0C9C4B-3777-4755-A87B-60FE65D92750} + {34D35A41-E974-40C9-8888-3510A0F074AA} = {90471225-AC23-424E-B62E-F6EC4C6ECAC0} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {F5273D7F-3334-48DF-94E3-41AE6816CD4D} diff --git a/build/cache/cl.json.gz b/build/cache/cl.json.gz index 6ef598a7d6..308956aef6 100644 Binary files a/build/cache/cl.json.gz and b/build/cache/cl.json.gz differ diff --git a/build/cache/gl.json.gz b/build/cache/gl.json.gz index 2c5fa0edcc..7c47c04cb9 100644 Binary files a/build/cache/gl.json.gz and b/build/cache/gl.json.gz differ diff --git a/build/cache/glcore.json.gz b/build/cache/glcore.json.gz index 06b39de36c..c5afff0eab 100644 Binary files a/build/cache/glcore.json.gz and b/build/cache/glcore.json.gz differ diff --git a/build/cache/gles2.json.gz b/build/cache/gles2.json.gz index d5df0e9522..ff00cd172f 100644 Binary files a/build/cache/gles2.json.gz and b/build/cache/gles2.json.gz differ diff --git a/build/cache/openxr.json.gz b/build/cache/openxr.json.gz index 32140d7311..c0403ed384 100644 Binary files a/build/cache/openxr.json.gz and b/build/cache/openxr.json.gz differ diff --git a/build/cache/vulkan.json.gz b/build/cache/vulkan.json.gz index 7b00239b89..8f83513975 100644 Binary files a/build/cache/vulkan.json.gz and b/build/cache/vulkan.json.gz differ diff --git a/build/props/common.props b/build/props/common.props index b4f5f6b052..96279580a6 100644 --- a/build/props/common.props +++ b/build/props/common.props @@ -12,54 +12,21 @@ 10 .NET Foundation and Contributors - Silk.NET October 2023 Update + Silk.NET November 2023 Update - - Added SPIR-V Reflect bindings - - Added SPIR-V Cross bindings - - Added Shaderc bindings - - Added WIC/WindowsCodecs bindings (thanks @hez2010) - - Added multi-channel formats support for OpenAL (thanks @aleksrutins) - - Added EffectTarget support for OpenAL Soft (thanks @okaniku, @doobah) - - Added MoltenVK support for iOS (massive thank you to @zvasya for contributing and testing) - - Added macOS support for the CreateWebGPUSurface helper function (thanks @AsgardXIV) - - Added the ability to load MoltenVK directly as a fallback should the Vulkan Loader be unavailable on macOS - - Added trimming support with an option to enable/disable static-linking support at link time - - Added WinRT interoperability support for Direct3D 11. - - Added the ability to query extensions from specific Vulkan layers using the Silk.NET helpers - - Added extension methods on IGamepad to return Thumbstick state instead of requiring use of the indexers (thanks @jvyden) - - Added ref properties for Vulkan chain constituents (thanks @khitiara) - - Added Apple Silicon binaries for Assimp (thanks @jschieck) - - Added compatibility with Linux distributions using as early as glibc 2.16 - - Added equality operators and IEquatable to Bool32 (thanks @Syncaidius) - - Added ToSystem/ToGeneric as extension methods (rather than plain static functions) to convert to/from Silk.NET.Maths types (thanks @Wafer-EX) - - Added discriminant values to PinObjectMarshaller to tie pinned handles to state to which the pin pertains - - Updated to Vulkan 1.3.266 - - Updated to OpenXR 1.0.30 - - Updated to SDL 2.28.1 - - Updated to MoltenVK 1.2.5 - - Updated to latest WebGPU headers - - Updated to latest OpenCL specifications + - Updated to OpenXR 1.0.31 + - Updated to Vulkan 1.3.270 + - Updated to latest ImGui.NET, alleviating some incompatibilities introduced by the ImGui.NET team. - Updated to latest OpenGL specifications - - Improved allocations in the Silk.NET Loader (thanks @Youssef1313) - - Improved robustness of HLU on AOT compilations - - Fixed WGPU not loading with the correct filename on Windows - - Fixed COM V-Table indices not matching the Clang-reported V-Table index in some cases (DirectWrite/D2D1/DComp) + - Fixed OpenCL clCreateImage not functioning as expected with ImageDesc's ABI - Fixed OpenAL throwing when loading an extension prefixed with ALC_ instead AL_ - - Fixed WGL.GetApi throwing a NotImplementedException - - Fixed library loading failing on platforms that do not have a libdl.so symlink (we are now using libdl.so.2, thanks @CasualPokePlayer) - - Fixed a StackOverflowException when using SetWindowIcon in some cases with Silk.NET.Windowing - - Fixed GLFW crashing in some cases where multiple windows are used - - Fixed WebGPU using the incorrect size for booleans - - Fixed a memory leak with some string marshalling functions - - If you are using Silk.NET with an iOS or Android application, please enable trimming and set TrimMode to full. OpenCL;OpenGL;OpenAL;OpenGLES;GLES;Vulkan;Assimp;DirectX;GLFW;SDL;Windowing;Input;Gamepad;Joystick;Keyboard;Mouse;SilkTouch;Source;Generator;C#;F#;.NET;DotNet;Mono;Vector;Math;Maths;Numerics;Game;Graphics;Compute;Audio;Sound;Engine;Silk;Silk.NET;Slim.NET;ElgarTK;GPU;Sharp;Science;Scientific;Visualization;Visual;Audiovisual;Windows;macOS;Linux;Android;Bindings;OSX;Wrapper;Native true $(MSBuildThisFileDirectory)/../output_packages https://github.com/dotnet/Silk.NET Git - 2.18.0 + 2.19.0 Silk.NET is a high-speed, advanced library, providing bindings to popular low-level APIs such as OpenGL, OpenCL, OpenAL, OpenXR, GLFW, SDL, Vulkan, Assimp, and DirectX. diff --git a/generator.json b/generator.json index 7c705b3eb3..b1a53106ab 100644 --- a/generator.json +++ b/generator.json @@ -290,6 +290,9 @@ "CL_PRINTF_CALLBACK_ARM": "CL_CONTEXT_PRINTF_CALLBACK_ARM", "CL_PRINTF_BUFFERSIZE_ARM": "CL_CONTEXT_PRINTF_BUFFERSIZE_ARM" }, + "exclude": [ + "cl_image_desc" + ], "bakery": { "profileNames": [ "opencl" @@ -345,7 +348,8 @@ "CL_CALLBACK_SetProgramReleaseCallback_pfn_notify*": "ObjectNotifyCallback", "CL_CALLBACK_SetEventCallback_pfn_notify*": "EventNotifyCallback", "CL_CALLBACK_EnqueueNativeKernel_user_func*": "UserFunction", - "CL_CALLBACK_BuildProgram_pfn_notify*": "ObjectNotifyCallback" + "CL_CALLBACK_BuildProgram_pfn_notify*": "ObjectNotifyCallback", + "cl_image_desc": "ImageDesc" }, { "$include.commonTypeMap": "build/csharp_typemap.json", diff --git a/src/OpenCL/Silk.NET.OpenCL/Structs/ImageDesc.gen.cs b/src/OpenCL/Silk.NET.OpenCL/Structs/ImageDesc.cs similarity index 95% rename from src/OpenCL/Silk.NET.OpenCL/Structs/ImageDesc.gen.cs rename to src/OpenCL/Silk.NET.OpenCL/Structs/ImageDesc.cs index e75861df22..90d044e872 100644 --- a/src/OpenCL/Silk.NET.OpenCL/Structs/ImageDesc.gen.cs +++ b/src/OpenCL/Silk.NET.OpenCL/Structs/ImageDesc.cs @@ -123,5 +123,10 @@ public ImageDesc [NativeName("Type.Name", "cl_uint")] [NativeName("Name", "num_samples")] public uint NumSamples; +/// + [NativeName("Type", "cl_mem")] + [NativeName("Type.Name", "cl_mem")] + [NativeName("Name", "mem_object")] + public nint MemObject; } } diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.ARB/ArbVertexAttrib64bit.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.ARB/ArbVertexAttrib64bit.gen.cs index fbb90f73e6..b3d849b0f4 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.ARB/ArbVertexAttrib64bit.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.ARB/ArbVertexAttrib64bit.gen.cs @@ -69,10 +69,10 @@ public unsafe partial class ArbVertexAttrib64bit : NativeExtension public partial void VertexAttribL4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in double v); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ARB type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ARB type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); public unsafe double GetVertexAttribL([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ARB pname) { diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.ARB/ArbVertexAttrib64bit.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.ARB/ArbVertexAttrib64bit.gen.cs index 7548420c57..8d0976fc08 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.ARB/ArbVertexAttrib64bit.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.ARB/ArbVertexAttrib64bit.gen.cs @@ -69,10 +69,10 @@ public unsafe partial class ArbVertexAttrib64bit : NativeExtension public partial void VertexAttribL4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in double v); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ARB type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ARB type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); public unsafe double GetVertexAttribL([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ARB pname) { diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/Enums/MESA.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/Enums/MESA.gen.cs index 99b39ae9c8..0cce4fb4be 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/Enums/MESA.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/Enums/MESA.gen.cs @@ -24,5 +24,7 @@ public enum MESA : int FramebufferSwapXYMesa = 0x8BBD, [NativeName("Name", "GL_PROGRAM_BINARY_FORMAT_MESA")] ProgramBinaryFormatMesa = 0x875F, + [NativeName("Name", "GL_SAMPLER_BINDING")] + SamplerBinding = 0x8919, } } diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/MesaSamplerObjects.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/MesaSamplerObjects.gen.cs new file mode 100644 index 0000000000..948e62fad9 --- /dev/null +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/MesaSamplerObjects.gen.cs @@ -0,0 +1,186 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.OpenGLES; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenGLES.Extensions.MESA +{ + [Extension("MESA_sampler_objects")] + public unsafe partial class MesaSamplerObjects : NativeExtension + { + public const string ExtensionName = "MESA_sampler_objects"; + [NativeApi(EntryPoint = "glBindSampler", Convention = CallingConvention.Winapi)] + public partial void BindSampler([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint unit, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler); + + [NativeApi(EntryPoint = "glDeleteSamplers", Convention = CallingConvention.Winapi)] + public unsafe partial void DeleteSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] uint* samplers); + + [NativeApi(EntryPoint = "glDeleteSamplers", Convention = CallingConvention.Winapi)] + public partial void DeleteSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] in uint samplers); + + [NativeApi(EntryPoint = "glDeleteSamplers", Convention = CallingConvention.Winapi)] + public unsafe partial void DeleteSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] Sampler* samplers); + + [NativeApi(EntryPoint = "glDeleteSamplers", Convention = CallingConvention.Winapi)] + public partial void DeleteSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Sampler samplers); + + [NativeApi(EntryPoint = "glGenSamplers", Convention = CallingConvention.Winapi)] + public unsafe partial void GenSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] uint* samplers); + + [NativeApi(EntryPoint = "glGenSamplers", Convention = CallingConvention.Winapi)] + public partial void GenSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out uint samplers); + + [NativeApi(EntryPoint = "glGenSamplers", Convention = CallingConvention.Winapi)] + public unsafe partial void GenSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Sampler* samplers); + + [NativeApi(EntryPoint = "glGenSamplers", Convention = CallingConvention.Winapi)] + public partial void GenSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out Sampler samplers); + + [NativeApi(EntryPoint = "glGetSamplerParameteriv", Convention = CallingConvention.Winapi)] + public unsafe partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] int* @params); + + [NativeApi(EntryPoint = "glGetSamplerParameteriv", Convention = CallingConvention.Winapi)] + public partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out int @params); + + [NativeApi(EntryPoint = "glGetSamplerParameteriv", Convention = CallingConvention.Winapi)] + public unsafe partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] int* @params); + + [NativeApi(EntryPoint = "glGetSamplerParameteriv", Convention = CallingConvention.Winapi)] + public partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out int @params); + + [NativeApi(EntryPoint = "glGetSamplerParameterfv", Convention = CallingConvention.Winapi)] + public unsafe partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] float* @params); + + [NativeApi(EntryPoint = "glGetSamplerParameterfv", Convention = CallingConvention.Winapi)] + public partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out float @params); + + [NativeApi(EntryPoint = "glGetSamplerParameterfv", Convention = CallingConvention.Winapi)] + public unsafe partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] float* @params); + + [NativeApi(EntryPoint = "glGetSamplerParameterfv", Convention = CallingConvention.Winapi)] + public partial void GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out float @params); + + [NativeApi(EntryPoint = "glIsSampler", Convention = CallingConvention.Winapi)] + public partial bool IsSampler([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler); + + [NativeApi(EntryPoint = "glSamplerParameteri", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int param); + + [NativeApi(EntryPoint = "glSamplerParameteri", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int param); + + [NativeApi(EntryPoint = "glSamplerParameteriv", Convention = CallingConvention.Winapi)] + public unsafe partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] int* param); + + [NativeApi(EntryPoint = "glSamplerParameteriv", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] in int param); + + [NativeApi(EntryPoint = "glSamplerParameteriv", Convention = CallingConvention.Winapi)] + public unsafe partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] int* param); + + [NativeApi(EntryPoint = "glSamplerParameteriv", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] in int param); + + [NativeApi(EntryPoint = "glSamplerParameterf", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float param); + + [NativeApi(EntryPoint = "glSamplerParameterf", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Flow(Silk.NET.Core.Native.FlowDirection.In)] float param); + + [NativeApi(EntryPoint = "glSamplerParameterfv", Convention = CallingConvention.Winapi)] + public unsafe partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] float* param); + + [NativeApi(EntryPoint = "glSamplerParameterfv", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] in float param); + + [NativeApi(EntryPoint = "glSamplerParameterfv", Convention = CallingConvention.Winapi)] + public unsafe partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] float* param); + + [NativeApi(EntryPoint = "glSamplerParameterfv", Convention = CallingConvention.Winapi)] + public partial void SamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] in float param); + + public unsafe void DeleteSampler([Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] uint samplers) + { + // ArrayParameterOverloader + DeleteSamplers(1, &samplers); + } + + public unsafe void DeleteSamplers([Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan samplers) + { + // ImplicitCountSpanOverloader + DeleteSamplers((uint) samplers.Length, in samplers.GetPinnableReference()); + } + + public unsafe void DeleteSamplers([Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan samplers) + { + // ImplicitCountSpanOverloader + DeleteSamplers((uint) samplers.Length, in samplers.GetPinnableReference()); + } + + public unsafe uint GenSampler() + { + const uint count = 1; + // ReturnTypeOverloader + uint ret = default; + GenSamplers(count, &ret); + return ret; + } + + public unsafe void GenSamplers([Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span samplers) + { + // ImplicitCountSpanOverloader + GenSamplers((uint) samplers.Length, out samplers.GetPinnableReference()); + } + + public unsafe void GenSamplers([Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span samplers) + { + // ImplicitCountSpanOverloader + GenSamplers((uint) samplers.Length, out samplers.GetPinnableReference()); + } + + public unsafe uint GenSamplers([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count) + { + // NonKhrReturnTypeOverloader + GenSamplers(count, out uint silkRet); + return silkRet; + } + + public unsafe int GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname) + { + // NonKhrReturnTypeOverloader + GetSamplerParameter(sampler, pname, out int silkRet); + return silkRet; + } + + public unsafe int GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname) + { + // NonKhrReturnTypeOverloader + GetSamplerParameter(sampler, pname, out int silkRet); + return silkRet; + } + + public unsafe float GetSamplerParameter([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname) + { + // NonKhrReturnTypeOverloader + GetSamplerParameter(sampler, pname, out float silkRet); + return silkRet; + } + + public MesaSamplerObjects(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/MesaSamplerObjectsOverloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/MesaSamplerObjectsOverloads.gen.cs new file mode 100644 index 0000000000..d27982c5bf --- /dev/null +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.MESA/MesaSamplerObjectsOverloads.gen.cs @@ -0,0 +1,93 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenGLES.Extensions.MESA +{ + public static class MesaSamplerObjectsOverloads + { + public static unsafe void DeleteSamplers(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan samplers) + { + // SpanOverloader + thisApi.DeleteSamplers(count, in samplers.GetPinnableReference()); + } + + public static unsafe void DeleteSamplers(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan samplers) + { + // SpanOverloader + thisApi.DeleteSamplers(count, in samplers.GetPinnableReference()); + } + + public static unsafe void GenSamplers(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span samplers) + { + // SpanOverloader + thisApi.GenSamplers(count, out samplers.GetPinnableReference()); + } + + public static unsafe void GenSamplers(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span samplers) + { + // SpanOverloader + thisApi.GenSamplers(count, out samplers.GetPinnableReference()); + } + + public static unsafe void GetSamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span @params) + { + // SpanOverloader + thisApi.GetSamplerParameter(sampler, pname, out @params.GetPinnableReference()); + } + + public static unsafe void GetSamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span @params) + { + // SpanOverloader + thisApi.GetSamplerParameter(sampler, pname, out @params.GetPinnableReference()); + } + + public static unsafe void GetSamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span @params) + { + // SpanOverloader + thisApi.GetSamplerParameter(sampler, pname, out @params.GetPinnableReference()); + } + + public static unsafe void GetSamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span @params) + { + // SpanOverloader + thisApi.GetSamplerParameter(sampler, pname, out @params.GetPinnableReference()); + } + + public static unsafe void SamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan param) + { + // SpanOverloader + thisApi.SamplerParameter(sampler, pname, in param.GetPinnableReference()); + } + + public static unsafe void SamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterI pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan param) + { + // SpanOverloader + thisApi.SamplerParameter(sampler, pname, in param.GetPinnableReference()); + } + + public static unsafe void SamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] MESA pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan param) + { + // SpanOverloader + thisApi.SamplerParameter(sampler, pname, in param.GetPinnableReference()); + } + + public static unsafe void SamplerParameter(this MesaSamplerObjects thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint sampler, [Flow(Silk.NET.Core.Native.FlowDirection.In)] SamplerParameterF pname, [Count(Computed = "pname"), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan param) + { + // SpanOverloader + thisApi.SamplerParameter(sampler, pname, in param.GetPinnableReference()); + } + + } +} + diff --git a/src/OpenGL/Silk.NET.OpenGL.Legacy/GL.gen.cs b/src/OpenGL/Silk.NET.OpenGL.Legacy/GL.gen.cs index 2de79f0a0c..3263c4c0c5 100644 --- a/src/OpenGL/Silk.NET.OpenGL.Legacy/GL.gen.cs +++ b/src/OpenGL/Silk.NET.OpenGL.Legacy/GL.gen.cs @@ -6048,10 +6048,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttribL4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in double v); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glViewportArrayv", Convention = CallingConvention.Winapi)] public unsafe partial void ViewportArray([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint first, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Computed = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] float* v); @@ -8570,10 +8570,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttribI4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in ushort v); [NativeApi(EntryPoint = "glVertexAttribIPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribIPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribIType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribIType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glUniformMatrix2x3fv", Convention = CallingConvention.Winapi)] public unsafe partial void UniformMatrix2x3([Flow(Silk.NET.Core.Native.FlowDirection.In)] int location, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool transpose, [Count(Parameter = "count", Expression = "*6"), Flow(Silk.NET.Core.Native.FlowDirection.In)] float* value); @@ -9509,10 +9509,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttrib4N([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in ushort v); [NativeApi(EntryPoint = "glVertexAttribPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribPointerType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribPointerType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glBeginQuery", Convention = CallingConvention.Winapi)] public partial void BeginQuery([Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum target, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint id); diff --git a/src/OpenGL/Silk.NET.OpenGL/GL.gen.cs b/src/OpenGL/Silk.NET.OpenGL/GL.gen.cs index 6f7fe82ca7..06da7307c6 100644 --- a/src/OpenGL/Silk.NET.OpenGL/GL.gen.cs +++ b/src/OpenGL/Silk.NET.OpenGL/GL.gen.cs @@ -6048,10 +6048,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttribL4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in double v); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribLPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Parameter = "size"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribLPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribLType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glViewportArrayv", Convention = CallingConvention.Winapi)] public unsafe partial void ViewportArray([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint first, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Count(Computed = "count"), Flow(Silk.NET.Core.Native.FlowDirection.In)] float* v); @@ -8570,10 +8570,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttribI4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in ushort v); [NativeApi(EntryPoint = "glVertexAttribIPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribIPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribIType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribIType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glUniformMatrix2x3fv", Convention = CallingConvention.Winapi)] public unsafe partial void UniformMatrix2x3([Flow(Silk.NET.Core.Native.FlowDirection.In)] int location, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint count, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool transpose, [Count(Parameter = "count", Expression = "*6"), Flow(Silk.NET.Core.Native.FlowDirection.In)] float* value); @@ -9509,10 +9509,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttrib4N([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in ushort v); [NativeApi(EntryPoint = "glVertexAttribPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribPointerType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribPointerType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glBeginQuery", Convention = CallingConvention.Winapi)] public partial void BeginQuery([Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum target, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint id); diff --git a/src/OpenGL/Silk.NET.OpenGLES/GL.gen.cs b/src/OpenGL/Silk.NET.OpenGLES/GL.gen.cs index 44c8e89e8c..5d1a3bcf52 100644 --- a/src/OpenGL/Silk.NET.OpenGLES/GL.gen.cs +++ b/src/OpenGL/Silk.NET.OpenGLES/GL.gen.cs @@ -4979,10 +4979,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttribI4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in uint v); [NativeApi(EntryPoint = "glVertexAttribIPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribIPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribIType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribIPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribIType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glWaitSync", Convention = CallingConvention.Winapi)] public partial void WaitSync([Flow(Silk.NET.Core.Native.FlowDirection.In)] nint sync, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ulong timeout); @@ -6793,10 +6793,10 @@ public unsafe partial class GL : NativeAPI public partial void VertexAttrib4([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Count(Count = 4), Flow(Silk.NET.Core.Native.FlowDirection.In)] in float v); [NativeApi(EntryPoint = "glVertexAttribPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] GLEnum type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glVertexAttribPointer", Convention = CallingConvention.Winapi)] - public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribPointerType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); + public unsafe partial void VertexAttribPointer([Flow(Silk.NET.Core.Native.FlowDirection.In)] uint index, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int size, [Flow(Silk.NET.Core.Native.FlowDirection.In)] VertexAttribPointerType type, [Flow(Silk.NET.Core.Native.FlowDirection.In)] bool normalized, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint stride, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pointer); [NativeApi(EntryPoint = "glViewport", Convention = CallingConvention.Winapi)] public partial void Viewport([Flow(Silk.NET.Core.Native.FlowDirection.In)] int x, [Flow(Silk.NET.Core.Native.FlowDirection.In)] int y, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint width, [Flow(Silk.NET.Core.Native.FlowDirection.In)] uint height); diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.ML/MLUserCalibration.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.ML/MLUserCalibration.gen.cs new file mode 100644 index 0000000000..da86b58014 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.ML/MLUserCalibration.gen.cs @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.OpenXR; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.ML +{ + [Extension("XR_ML_user_calibration")] + public unsafe partial class MLUserCalibration : NativeExtension + { + public const string ExtensionName = "XR_ML_user_calibration"; + /// To be documented. + [NativeApi(EntryPoint = "xrEnableUserCalibrationEventsML", Convention = CallingConvention.Winapi)] + public unsafe partial Result EnableUserCalibrationEventsML([Count(Count = 0)] Instance instance, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] UserCalibrationEnableEventsInfoML* enableInfo); + + /// To be documented. + [NativeApi(EntryPoint = "xrEnableUserCalibrationEventsML", Convention = CallingConvention.Winapi)] + public partial Result EnableUserCalibrationEventsML([Count(Count = 0)] Instance instance, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in UserCalibrationEnableEventsInfoML enableInfo); + + public MLUserCalibration(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.ML/MLUserCalibrationOverloads.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.ML/MLUserCalibrationOverloads.gen.cs new file mode 100644 index 0000000000..f38dd23143 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.ML/MLUserCalibrationOverloads.gen.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.ML +{ + public static class MLUserCalibrationOverloads + { + /// To be documented. + public static unsafe Result EnableUserCalibrationEventsML(this MLUserCalibration thisApi, [Count(Count = 0)] Instance instance, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan enableInfo) + { + // SpanOverloader + return thisApi.EnableUserCalibrationEventsML(instance, in enableInfo.GetPinnableReference()); + } + + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSceneMarker.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSceneMarker.gen.cs new file mode 100644 index 0000000000..ca017994ed --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSceneMarker.gen.cs @@ -0,0 +1,181 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.OpenXR; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.MSFT +{ + [Extension("XR_MSFT_scene_marker")] + public unsafe partial class MsftSceneMarker : NativeExtension + { + public const string ExtensionName = "XR_MSFT_scene_marker"; + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerDecodedStringMSFT", Convention = CallingConvention.Winapi)] + public partial Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] ref byte buffer); + + /// To be documented. + [NativeApi(EntryPoint = "xrGetSceneMarkerRawDataMSFT", Convention = CallingConvention.Winapi)] + public partial Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] ref uint bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer); + + /// To be documented. + public unsafe Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerDecodedStringMsft(scene, markerId, (uint) buffer.Length, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerDecodedStringMsft(scene, markerId, (uint) buffer.Length, ref bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerDecodedStringMsft(scene, in markerId, (uint) buffer.Length, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerDecodedStringMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerDecodedStringMsft(scene, in markerId, (uint) buffer.Length, ref bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerRawDataMsft(scene, markerId, (uint) buffer.Length, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerRawDataMsft(scene, markerId, (uint) buffer.Length, ref bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerRawDataMsft(scene, in markerId, (uint) buffer.Length, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result GetSceneMarkerRawDataMsft([Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid markerId, [Count(Count = 0)] ref uint bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // ImplicitCountSpanOverloader + return GetSceneMarkerRawDataMsft(scene, in markerId, (uint) buffer.Length, ref bufferCountOutput, ref buffer.GetPinnableReference()); + } + + public MsftSceneMarker(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSceneMarkerOverloads.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSceneMarkerOverloads.gen.cs new file mode 100644 index 0000000000..545d444020 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSceneMarkerOverloads.gen.cs @@ -0,0 +1,161 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.MSFT +{ + public static class MsftSceneMarkerOverloads + { + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, markerId, bufferCapacityInput, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, markerId, bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, markerId, bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, markerId, bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, bufferCountOutput, buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, bufferCountOutput, buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerDecodedStringMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerDecodedStringMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, markerId, bufferCapacityInput, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, markerId, bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, markerId, bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, markerId, bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, bufferCountOutput, buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, bufferCountOutput, ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] uint* bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, bufferCountOutput, buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] byte* buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [Count(Parameter = "bufferCapacityInput")] Span buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), ref buffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetSceneMarkerRawDataMsft(this MsftSceneMarker thisApi, [Count(Count = 0)] SceneMSFT scene, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan markerId, [Count(Count = 0)] uint bufferCapacityInput, [Count(Count = 0)] Span bufferCountOutput, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string buffer) + { + // SpanOverloader + return thisApi.GetSceneMarkerRawDataMsft(scene, in markerId.GetPinnableReference(), bufferCapacityInput, ref bufferCountOutput.GetPinnableReference(), buffer); + } + + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs index f1c02928d2..0c4982159d 100644 --- a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs @@ -54,19 +54,19 @@ public unsafe partial class MsftSpatialAnchorPersistence : NativeExtension /// To be documented. [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT", Convention = CallingConvention.Winapi)] - public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] SpatialAnchorPersistenceNameMSFT* persistedAnchorNames); + public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] uint* spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] SpatialAnchorPersistenceNameMSFT* spatialAnchorNames); /// To be documented. [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT", Convention = CallingConvention.Winapi)] - public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] ref SpatialAnchorPersistenceNameMSFT persistedAnchorNames); + public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] uint* spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] ref SpatialAnchorPersistenceNameMSFT spatialAnchorNames); /// To be documented. [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT", Convention = CallingConvention.Winapi)] - public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] ref uint spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] SpatialAnchorPersistenceNameMSFT* persistedAnchorNames); + public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] ref uint spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] SpatialAnchorPersistenceNameMSFT* spatialAnchorNames); /// To be documented. [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT", Convention = CallingConvention.Winapi)] - public partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] ref uint spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] ref SpatialAnchorPersistenceNameMSFT persistedAnchorNames); + public partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] ref uint spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] ref SpatialAnchorPersistenceNameMSFT spatialAnchorNames); /// To be documented. [NativeApi(EntryPoint = "xrPersistSpatialAnchorMSFT", Convention = CallingConvention.Winapi)] @@ -85,17 +85,17 @@ public unsafe partial class MsftSpatialAnchorPersistence : NativeExtension public partial Result UnpersistSpatialAnchorMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in SpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName); /// To be documented. - public unsafe Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + public unsafe Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint* spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] Span spatialAnchorNames) { // ImplicitCountSpanOverloader - return EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, (uint) persistedAnchorNames.Length, spatialAnchorNamesCountOutput, ref persistedAnchorNames.GetPinnableReference()); + return EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, (uint) spatialAnchorNames.Length, spatialAnchorNameCountOutput, ref spatialAnchorNames.GetPinnableReference()); } /// To be documented. - public unsafe Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] ref uint spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + public unsafe Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] ref uint spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] Span spatialAnchorNames) { // ImplicitCountSpanOverloader - return EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, (uint) persistedAnchorNames.Length, ref spatialAnchorNamesCountOutput, ref persistedAnchorNames.GetPinnableReference()); + return EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, (uint) spatialAnchorNames.Length, ref spatialAnchorNameCountOutput, ref spatialAnchorNames.GetPinnableReference()); } public MsftSpatialAnchorPersistence(INativeContext ctx) diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs index 86b0d7a82e..cfa6c0c16c 100644 --- a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs @@ -45,24 +45,24 @@ public static unsafe Result CreateSpatialAnchorStoreConnectionMsft(this MsftSpat } /// To be documented. - public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] uint* spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] Span spatialAnchorNames) { // SpanOverloader - return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNamesCapacityInput, spatialAnchorNamesCountOutput, ref persistedAnchorNames.GetPinnableReference()); + return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNameCapacityInput, spatialAnchorNameCountOutput, ref spatialAnchorNames.GetPinnableReference()); } /// To be documented. - public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] Span spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] SpatialAnchorPersistenceNameMSFT* persistedAnchorNames) + public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] Span spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] SpatialAnchorPersistenceNameMSFT* spatialAnchorNames) { // SpanOverloader - return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNamesCapacityInput, ref spatialAnchorNamesCountOutput.GetPinnableReference(), persistedAnchorNames); + return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNameCapacityInput, ref spatialAnchorNameCountOutput.GetPinnableReference(), spatialAnchorNames); } /// To be documented. - public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] Span spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNameCapacityInput, [Count(Count = 0)] Span spatialAnchorNameCountOutput, [Count(Parameter = "spatialAnchorNameCapacityInput")] Span spatialAnchorNames) { // SpanOverloader - return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNamesCapacityInput, ref spatialAnchorNamesCountOutput.GetPinnableReference(), ref persistedAnchorNames.GetPinnableReference()); + return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNameCapacityInput, ref spatialAnchorNameCountOutput.GetPinnableReference(), ref spatialAnchorNames.GetPinnableReference()); } /// To be documented. diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.NV/Silk.NET.OpenXR.Extensions.NV.csproj b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.NV/Silk.NET.OpenXR.Extensions.NV.csproj new file mode 100644 index 0000000000..50c0b3add5 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.NV/Silk.NET.OpenXR.Extensions.NV.csproj @@ -0,0 +1,14 @@ + + + + netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0 + true + 10 + + + + + + + + diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/EyeCalibrationStatusML.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/EyeCalibrationStatusML.gen.cs new file mode 100644 index 0000000000..7bd467b665 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/EyeCalibrationStatusML.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrEyeCalibrationStatusML")] + public enum EyeCalibrationStatusML : int + { + [Obsolete("Deprecated in favour of \"UnknownML\"")] + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML")] + EyeCalibrationStatusUnknownML = 0, + [Obsolete("Deprecated in favour of \"NoneML\"")] + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_NONE_ML")] + EyeCalibrationStatusNoneML = 1, + [Obsolete("Deprecated in favour of \"CoarseML\"")] + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_COARSE_ML")] + EyeCalibrationStatusCoarseML = 2, + [Obsolete("Deprecated in favour of \"FineML\"")] + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_FINE_ML")] + EyeCalibrationStatusFineML = 3, + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML")] + UnknownML = 0, + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_NONE_ML")] + NoneML = 1, + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_COARSE_ML")] + CoarseML = 2, + [NativeName("Name", "XR_EYE_CALIBRATION_STATUS_FINE_ML")] + FineML = 3, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/HeadsetFitStatusML.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/HeadsetFitStatusML.gen.cs new file mode 100644 index 0000000000..e3118d9bec --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/HeadsetFitStatusML.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrHeadsetFitStatusML")] + public enum HeadsetFitStatusML : int + { + [Obsolete("Deprecated in favour of \"UnknownML\"")] + [NativeName("Name", "XR_HEADSET_FIT_STATUS_UNKNOWN_ML")] + HeadsetFitStatusUnknownML = 0, + [Obsolete("Deprecated in favour of \"NotWornML\"")] + [NativeName("Name", "XR_HEADSET_FIT_STATUS_NOT_WORN_ML")] + HeadsetFitStatusNotWornML = 1, + [Obsolete("Deprecated in favour of \"GoodFitML\"")] + [NativeName("Name", "XR_HEADSET_FIT_STATUS_GOOD_FIT_ML")] + HeadsetFitStatusGoodFitML = 2, + [Obsolete("Deprecated in favour of \"BadFitML\"")] + [NativeName("Name", "XR_HEADSET_FIT_STATUS_BAD_FIT_ML")] + HeadsetFitStatusBadFitML = 3, + [NativeName("Name", "XR_HEADSET_FIT_STATUS_UNKNOWN_ML")] + UnknownML = 0, + [NativeName("Name", "XR_HEADSET_FIT_STATUS_NOT_WORN_ML")] + NotWornML = 1, + [NativeName("Name", "XR_HEADSET_FIT_STATUS_GOOD_FIT_ML")] + GoodFitML = 2, + [NativeName("Name", "XR_HEADSET_FIT_STATUS_BAD_FIT_ML")] + BadFitML = 3, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs index 4c74aa4ecf..3edb80e28a 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs @@ -182,6 +182,8 @@ public enum Result : int ErrorSpatialAnchorNameNotFoundMsft = unchecked((int) -1000142001), [NativeName("Name", "XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT")] ErrorSpatialAnchorNameInvalidMsft = unchecked((int) -1000142002), + [NativeName("Name", "XR_SCENE_MARKER_DATA_NOT_STRING_MSFT")] + SceneMarkerDataNotStringMsft = 1000147000, [NativeName("Name", "XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB")] ErrorSpaceMappingInsufficientFB = unchecked((int) -1000169000), [NativeName("Name", "XR_ERROR_SPACE_LOCALIZATION_FAILED_FB")] diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComponentTypeMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComponentTypeMSFT.gen.cs index 780fb967bd..7ff70b5785 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComponentTypeMSFT.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComponentTypeMSFT.gen.cs @@ -33,6 +33,9 @@ public enum SceneComponentTypeMSFT : int [Obsolete("Deprecated in favour of \"SerializedSceneFragmentMsft\"")] [NativeName("Name", "XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT")] SceneComponentTypeSerializedSceneFragmentMsft = 1000098000, + [Obsolete("Deprecated in favour of \"MarkerMsft\"")] + [NativeName("Name", "XR_SCENE_COMPONENT_TYPE_MARKER_MSFT")] + SceneComponentTypeMarkerMsft = 1000147000, [NativeName("Name", "XR_SCENE_COMPONENT_TYPE_INVALID_MSFT")] InvalidMsft = unchecked((int) -1), [NativeName("Name", "XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT")] @@ -45,5 +48,7 @@ public enum SceneComponentTypeMSFT : int ColliderMeshMsft = 4, [NativeName("Name", "XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT")] SerializedSceneFragmentMsft = 1000098000, + [NativeName("Name", "XR_SCENE_COMPONENT_TYPE_MARKER_MSFT")] + MarkerMsft = 1000147000, } } diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComputeFeatureMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComputeFeatureMSFT.gen.cs index 49fbeab670..bbf99f090d 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComputeFeatureMSFT.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneComputeFeatureMSFT.gen.cs @@ -9,9 +9,12 @@ namespace Silk.NET.OpenXR { + [Flags] [NativeName("Name", "XrSceneComputeFeatureMSFT")] public enum SceneComputeFeatureMSFT : int { + [NativeName("Name", "")] + None = 0, [Obsolete("Deprecated in favour of \"PlaneMsft\"")] [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT")] SceneComputeFeaturePlaneMsft = 1, @@ -27,6 +30,9 @@ public enum SceneComputeFeatureMSFT : int [Obsolete("Deprecated in favour of \"SerializeSceneMsft\"")] [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT")] SceneComputeFeatureSerializeSceneMsft = 1000098000, + [Obsolete("Deprecated in favour of \"MarkerMsft\"")] + [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_MARKER_MSFT")] + SceneComputeFeatureMarkerMsft = 1000147000, [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT")] PlaneMsft = 1, [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT")] @@ -37,5 +43,7 @@ public enum SceneComputeFeatureMSFT : int ColliderMeshMsft = 4, [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT")] SerializeSceneMsft = 1000098000, + [NativeName("Name", "XR_SCENE_COMPUTE_FEATURE_MARKER_MSFT")] + MarkerMsft = 1000147000, } } diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SceneMarkerQRCodeSymbolTypeMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneMarkerQRCodeSymbolTypeMSFT.gen.cs new file mode 100644 index 0000000000..f5fff333c2 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneMarkerQRCodeSymbolTypeMSFT.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkerQRCodeSymbolTypeMSFT")] + public enum SceneMarkerQRCodeSymbolTypeMSFT : int + { + [Obsolete("Deprecated in favour of \"QRCodeMsft\"")] + [NativeName("Name", "XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT")] + SceneMarkerQRCodeSymbolTypeQRCodeMsft = 1, + [Obsolete("Deprecated in favour of \"MicroQRCodeMsft\"")] + [NativeName("Name", "XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT")] + SceneMarkerQRCodeSymbolTypeMicroQRCodeMsft = 2, + [NativeName("Name", "XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT")] + QRCodeMsft = 1, + [NativeName("Name", "XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT")] + MicroQRCodeMsft = 2, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SceneMarkerTypeMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneMarkerTypeMSFT.gen.cs new file mode 100644 index 0000000000..b684094a62 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SceneMarkerTypeMSFT.gen.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkerTypeMSFT")] + public enum SceneMarkerTypeMSFT : int + { + [Obsolete("Deprecated in favour of \"QRCodeMsft\"")] + [NativeName("Name", "XR_SCENE_MARKER_TYPE_QR_CODE_MSFT")] + SceneMarkerTypeQRCodeMsft = 1, + [NativeName("Name", "XR_SCENE_MARKER_TYPE_QR_CODE_MSFT")] + QRCodeMsft = 1, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs index 902fff1b7e..6366395d1b 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs @@ -654,12 +654,30 @@ public enum StructureType : int [Obsolete("Deprecated in favour of \"CoordinateSpaceCreateInfoML\"")] [NativeName("Name", "XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML")] TypeCoordinateSpaceCreateInfoML = 1000137000, + [Obsolete("Deprecated in favour of \"EventDataHeadsetFitChangedML\"")] + [NativeName("Name", "XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML")] + TypeEventDataHeadsetFitChangedML = 1000472000, + [Obsolete("Deprecated in favour of \"EventDataEyeCalibrationChangedML\"")] + [NativeName("Name", "XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML")] + TypeEventDataEyeCalibrationChangedML = 1000472001, + [Obsolete("Deprecated in favour of \"UserCalibrationEnableEventsInfoML\"")] + [NativeName("Name", "XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML")] + TypeUserCalibrationEnableEventsInfoML = 1000472002, [Obsolete("Deprecated in favour of \"SpatialAnchorPersistenceInfoMsft\"")] [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT")] TypeSpatialAnchorPersistenceInfoMsft = 1000142000, [Obsolete("Deprecated in favour of \"SpatialAnchorFromPersistedAnchorCreateInfoMsft\"")] [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT")] TypeSpatialAnchorFromPersistedAnchorCreateInfoMsft = 1000142001, + [Obsolete("Deprecated in favour of \"SceneMarkersMsft\"")] + [NativeName("Name", "XR_TYPE_SCENE_MARKERS_MSFT")] + TypeSceneMarkersMsft = 1000147000, + [Obsolete("Deprecated in favour of \"SceneMarkerTypeFilterMsft\"")] + [NativeName("Name", "XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT")] + TypeSceneMarkerTypeFilterMsft = 1000147001, + [Obsolete("Deprecated in favour of \"SceneMarkerQRCodesMsft\"")] + [NativeName("Name", "XR_TYPE_SCENE_MARKER_QR_CODES_MSFT")] + TypeSceneMarkerQRCodesMsft = 1000147002, [Obsolete("Deprecated in favour of \"SpaceQueryInfoFB\"")] [NativeName("Name", "XR_TYPE_SPACE_QUERY_INFO_FB")] TypeSpaceQueryInfoFB = 1000156001, @@ -1370,10 +1388,22 @@ public enum StructureType : int GlobalDimmerFrameEndInfoML = 1000136000, [NativeName("Name", "XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML")] CoordinateSpaceCreateInfoML = 1000137000, + [NativeName("Name", "XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML")] + EventDataHeadsetFitChangedML = 1000472000, + [NativeName("Name", "XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML")] + EventDataEyeCalibrationChangedML = 1000472001, + [NativeName("Name", "XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML")] + UserCalibrationEnableEventsInfoML = 1000472002, [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT")] SpatialAnchorPersistenceInfoMsft = 1000142000, [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT")] SpatialAnchorFromPersistedAnchorCreateInfoMsft = 1000142001, + [NativeName("Name", "XR_TYPE_SCENE_MARKERS_MSFT")] + SceneMarkersMsft = 1000147000, + [NativeName("Name", "XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT")] + SceneMarkerTypeFilterMsft = 1000147001, + [NativeName("Name", "XR_TYPE_SCENE_MARKER_QR_CODES_MSFT")] + SceneMarkerQRCodesMsft = 1000147002, [NativeName("Name", "XR_TYPE_SPACE_QUERY_INFO_FB")] SpaceQueryInfoFB = 1000156001, [NativeName("Name", "XR_TYPE_SPACE_QUERY_RESULTS_FB")] diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/EventDataEyeCalibrationChangedML.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/EventDataEyeCalibrationChangedML.gen.cs new file mode 100644 index 0000000000..bda1fca5f7 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/EventDataEyeCalibrationChangedML.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrEventDataEyeCalibrationChangedML")] + public unsafe partial struct EventDataEyeCalibrationChangedML + { + public EventDataEyeCalibrationChangedML + ( + StructureType? type = StructureType.TypeEventDataEyeCalibrationChangedML, + void* next = null, + EyeCalibrationStatusML? status = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (status is not null) + { + Status = status.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrEyeCalibrationStatusML")] + [NativeName("Type.Name", "XrEyeCalibrationStatusML")] + [NativeName("Name", "status")] + public EyeCalibrationStatusML Status; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/EventDataHeadsetFitChangedML.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/EventDataHeadsetFitChangedML.gen.cs new file mode 100644 index 0000000000..35a63d4274 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/EventDataHeadsetFitChangedML.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrEventDataHeadsetFitChangedML")] + public unsafe partial struct EventDataHeadsetFitChangedML + { + public EventDataHeadsetFitChangedML + ( + StructureType? type = StructureType.TypeEventDataHeadsetFitChangedML, + void* next = null, + HeadsetFitStatusML? status = null, + long? time = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (status is not null) + { + Status = status.Value; + } + + if (time is not null) + { + Time = time.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrHeadsetFitStatusML")] + [NativeName("Type.Name", "XrHeadsetFitStatusML")] + [NativeName("Name", "status")] + public HeadsetFitStatusML Status; +/// + [NativeName("Type", "XrTime")] + [NativeName("Type.Name", "XrTime")] + [NativeName("Name", "time")] + public long Time; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerMSFT.gen.cs new file mode 100644 index 0000000000..ff89e4ae44 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerMSFT.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkerMSFT")] + public unsafe partial struct SceneMarkerMSFT + { + public SceneMarkerMSFT + ( + SceneMarkerTypeMSFT? markerType = null, + long? lastSeenTime = null, + Offset2Df? center = null, + Extent2Df? size = null + ) : this() + { + if (markerType is not null) + { + MarkerType = markerType.Value; + } + + if (lastSeenTime is not null) + { + LastSeenTime = lastSeenTime.Value; + } + + if (center is not null) + { + Center = center.Value; + } + + if (size is not null) + { + Size = size.Value; + } + } + +/// + [NativeName("Type", "XrSceneMarkerTypeMSFT")] + [NativeName("Type.Name", "XrSceneMarkerTypeMSFT")] + [NativeName("Name", "markerType")] + public SceneMarkerTypeMSFT MarkerType; +/// + [NativeName("Type", "XrTime")] + [NativeName("Type.Name", "XrTime")] + [NativeName("Name", "lastSeenTime")] + public long LastSeenTime; +/// + [NativeName("Type", "XrOffset2Df")] + [NativeName("Type.Name", "XrOffset2Df")] + [NativeName("Name", "center")] + public Offset2Df Center; +/// + [NativeName("Type", "XrExtent2Df")] + [NativeName("Type.Name", "XrExtent2Df")] + [NativeName("Name", "size")] + public Extent2Df Size; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerQRCodeMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerQRCodeMSFT.gen.cs new file mode 100644 index 0000000000..8a26a5f100 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerQRCodeMSFT.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkerQRCodeMSFT")] + public unsafe partial struct SceneMarkerQRCodeMSFT + { + public SceneMarkerQRCodeMSFT + ( + SceneMarkerQRCodeSymbolTypeMSFT? symbolType = null, + byte? version = null + ) : this() + { + if (symbolType is not null) + { + SymbolType = symbolType.Value; + } + + if (version is not null) + { + Version = version.Value; + } + } + +/// + [NativeName("Type", "XrSceneMarkerQRCodeSymbolTypeMSFT")] + [NativeName("Type.Name", "XrSceneMarkerQRCodeSymbolTypeMSFT")] + [NativeName("Name", "symbolType")] + public SceneMarkerQRCodeSymbolTypeMSFT SymbolType; +/// + [NativeName("Type", "uint8_t")] + [NativeName("Type.Name", "uint8_t")] + [NativeName("Name", "version")] + public byte Version; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerQRCodesMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerQRCodesMSFT.gen.cs new file mode 100644 index 0000000000..8059f4ca54 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerQRCodesMSFT.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkerQRCodesMSFT")] + public unsafe partial struct SceneMarkerQRCodesMSFT + { + public SceneMarkerQRCodesMSFT + ( + StructureType? type = StructureType.TypeSceneMarkerQRCodesMsft, + void* next = null, + uint? qrCodeCapacityInput = null, + SceneMarkerQRCodeMSFT* qrCodes = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (qrCodeCapacityInput is not null) + { + QrCodeCapacityInput = qrCodeCapacityInput.Value; + } + + if (qrCodes is not null) + { + QrCodes = qrCodes; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "qrCodeCapacityInput")] + public uint QrCodeCapacityInput; +/// + [NativeName("Type", "XrSceneMarkerQRCodeMSFT*")] + [NativeName("Type.Name", "XrSceneMarkerQRCodeMSFT")] + [NativeName("Name", "qrCodes")] + public SceneMarkerQRCodeMSFT* QrCodes; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerTypeFilterMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerTypeFilterMSFT.gen.cs new file mode 100644 index 0000000000..81cc73c4f4 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkerTypeFilterMSFT.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkerTypeFilterMSFT")] + public unsafe partial struct SceneMarkerTypeFilterMSFT + { + public SceneMarkerTypeFilterMSFT + ( + StructureType? type = StructureType.TypeSceneMarkerTypeFilterMsft, + void* next = null, + uint? markerTypeCount = null, + SceneMarkerTypeMSFT* markerTypes = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (markerTypeCount is not null) + { + MarkerTypeCount = markerTypeCount.Value; + } + + if (markerTypes is not null) + { + MarkerTypes = markerTypes; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "markerTypeCount")] + public uint MarkerTypeCount; +/// + [NativeName("Type", "XrSceneMarkerTypeMSFT*")] + [NativeName("Type.Name", "XrSceneMarkerTypeMSFT")] + [NativeName("Name", "markerTypes")] + public SceneMarkerTypeMSFT* MarkerTypes; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkersMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkersMSFT.gen.cs new file mode 100644 index 0000000000..665dc877fc --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SceneMarkersMSFT.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSceneMarkersMSFT")] + public unsafe partial struct SceneMarkersMSFT + { + public SceneMarkersMSFT + ( + StructureType? type = StructureType.TypeSceneMarkersMsft, + void* next = null, + uint? sceneMarkerCapacityInput = null, + SceneMarkerMSFT* sceneMarkers = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (sceneMarkerCapacityInput is not null) + { + SceneMarkerCapacityInput = sceneMarkerCapacityInput.Value; + } + + if (sceneMarkers is not null) + { + SceneMarkers = sceneMarkers; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "sceneMarkerCapacityInput")] + public uint SceneMarkerCapacityInput; +/// + [NativeName("Type", "XrSceneMarkerMSFT*")] + [NativeName("Type.Name", "XrSceneMarkerMSFT")] + [NativeName("Name", "sceneMarkers")] + public SceneMarkerMSFT* SceneMarkers; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/UserCalibrationEnableEventsInfoML.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/UserCalibrationEnableEventsInfoML.gen.cs new file mode 100644 index 0000000000..b022ff81d3 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/UserCalibrationEnableEventsInfoML.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrUserCalibrationEnableEventsInfoML")] + public unsafe partial struct UserCalibrationEnableEventsInfoML + { + public UserCalibrationEnableEventsInfoML + ( + StructureType? type = StructureType.TypeUserCalibrationEnableEventsInfoML, + void* next = null, + uint? enabled = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (enabled is not null) + { + Enabled = enabled.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrBool32")] + [NativeName("Type.Name", "XrBool32")] + [NativeName("Name", "enabled")] + public uint Enabled; + } +} diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVCudaKernelLaunch.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVCudaKernelLaunch.gen.cs new file mode 100644 index 0000000000..7a37890909 --- /dev/null +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVCudaKernelLaunch.gen.cs @@ -0,0 +1,133 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.Vulkan; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan.Extensions.NV +{ + [Extension("VK_NV_cuda_kernel_launch")] + public unsafe partial class NVCudaKernelLaunch : NativeExtension + { + public const string ExtensionName = "VK_NV_cuda_kernel_launch"; + /// To be documented. + [NativeApi(EntryPoint = "vkCmdCudaLaunchKernelNV", Convention = CallingConvention.Winapi)] + public unsafe partial void CmdCudaLaunchKernel([Count(Count = 0)] CommandBuffer commandBuffer, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaLaunchInfoNV* pLaunchInfo); + + /// To be documented. + [NativeApi(EntryPoint = "vkCmdCudaLaunchKernelNV", Convention = CallingConvention.Winapi)] + public partial void CmdCudaLaunchKernel([Count(Count = 0)] CommandBuffer commandBuffer, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaLaunchInfoNV pLaunchInfo); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaFunctionNV pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaFunctionNV pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaFunctionCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaFunctionCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaFunctionNV pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaFunctionCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaFunctionNV", Convention = CallingConvention.Winapi)] + public partial Result CreateCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaFunctionCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaFunctionNV pFunction); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaModuleNV pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaModuleNV pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaModuleCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaModuleCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaModuleNV pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaModuleCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkCreateCudaModuleNV", Convention = CallingConvention.Winapi)] + public partial Result CreateCudaModule([Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in CudaModuleCreateInfoNV pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] out CudaModuleNV pModule); + + /// To be documented. + [NativeApi(EntryPoint = "vkDestroyCudaFunctionNV", Convention = CallingConvention.Winapi)] + public unsafe partial void DestroyCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0)] CudaFunctionNV function, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator); + + /// To be documented. + [NativeApi(EntryPoint = "vkDestroyCudaFunctionNV", Convention = CallingConvention.Winapi)] + public partial void DestroyCudaFunction([Count(Count = 0)] Device device, [Count(Count = 0)] CudaFunctionNV function, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator); + + /// To be documented. + [NativeApi(EntryPoint = "vkDestroyCudaModuleNV", Convention = CallingConvention.Winapi)] + public unsafe partial void DestroyCudaModule([Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator); + + /// To be documented. + [NativeApi(EntryPoint = "vkDestroyCudaModuleNV", Convention = CallingConvention.Winapi)] + public partial void DestroyCudaModule([Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] in AllocationCallbacks pAllocator); + + /// To be documented. + [NativeApi(EntryPoint = "vkGetCudaModuleCacheNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetCudaModuleCache([Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] nuint* pCacheSize, [Count(Parameter = "pCacheSize")] void* pCacheData); + + /// To be documented. + [NativeApi(EntryPoint = "vkGetCudaModuleCacheNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetCudaModuleCache([Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] nuint* pCacheSize, [Count(Parameter = "pCacheSize")] ref T0 pCacheData) where T0 : unmanaged; + + /// To be documented. + [NativeApi(EntryPoint = "vkGetCudaModuleCacheNV", Convention = CallingConvention.Winapi)] + public unsafe partial Result GetCudaModuleCache([Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] ref nuint pCacheSize, [Count(Parameter = "pCacheSize")] void* pCacheData); + + /// To be documented. + [NativeApi(EntryPoint = "vkGetCudaModuleCacheNV", Convention = CallingConvention.Winapi)] + public partial Result GetCudaModuleCache([Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] ref nuint pCacheSize, [Count(Parameter = "pCacheSize")] ref T0 pCacheData) where T0 : unmanaged; + + public NVCudaKernelLaunch(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVCudaKernelLaunchOverloads.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVCudaKernelLaunchOverloads.gen.cs new file mode 100644 index 0000000000..759f8db464 --- /dev/null +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVCudaKernelLaunchOverloads.gen.cs @@ -0,0 +1,161 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan.Extensions.NV +{ + public static class NVCudaKernelLaunchOverloads + { + /// To be documented. + public static unsafe void CmdCudaLaunchKernel(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] CommandBuffer commandBuffer, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pLaunchInfo) + { + // SpanOverloader + thisApi.CmdCudaLaunchKernel(commandBuffer, in pLaunchInfo.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, pCreateInfo, pAllocator, out pFunction.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, pCreateInfo, in pAllocator.GetPinnableReference(), pFunction); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaFunctionCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, pCreateInfo, in pAllocator.GetPinnableReference(), out pFunction.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, in pCreateInfo.GetPinnableReference(), pAllocator, pFunction); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, in pCreateInfo.GetPinnableReference(), pAllocator, out pFunction.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaFunctionNV* pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, in pCreateInfo.GetPinnableReference(), in pAllocator.GetPinnableReference(), pFunction); + } + + /// To be documented. + public static unsafe Result CreateCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pFunction) + { + // SpanOverloader + return thisApi.CreateCudaFunction(device, in pCreateInfo.GetPinnableReference(), in pAllocator.GetPinnableReference(), out pFunction.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, pCreateInfo, pAllocator, out pModule.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, pCreateInfo, in pAllocator.GetPinnableReference(), pModule); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] CudaModuleCreateInfoNV* pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, pCreateInfo, in pAllocator.GetPinnableReference(), out pModule.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, in pCreateInfo.GetPinnableReference(), pAllocator, pModule); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] AllocationCallbacks* pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, in pCreateInfo.GetPinnableReference(), pAllocator, out pModule.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] CudaModuleNV* pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, in pCreateInfo.GetPinnableReference(), in pAllocator.GetPinnableReference(), pModule); + } + + /// To be documented. + public static unsafe Result CreateCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pCreateInfo, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.Out)] Span pModule) + { + // SpanOverloader + return thisApi.CreateCudaModule(device, in pCreateInfo.GetPinnableReference(), in pAllocator.GetPinnableReference(), out pModule.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void DestroyCudaFunction(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] CudaFunctionNV function, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator) + { + // SpanOverloader + thisApi.DestroyCudaFunction(device, function, in pAllocator.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void DestroyCudaModule(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0), Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pAllocator) + { + // SpanOverloader + thisApi.DestroyCudaModule(device, module, in pAllocator.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetCudaModuleCache(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] nuint* pCacheSize, [Count(Parameter = "pCacheSize")] Span pCacheData) where T0 : unmanaged + { + // SpanOverloader + return thisApi.GetCudaModuleCache(device, module, pCacheSize, ref pCacheData.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetCudaModuleCache(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] Span pCacheSize, [Count(Parameter = "pCacheSize")] void* pCacheData) + { + // SpanOverloader + return thisApi.GetCudaModuleCache(device, module, ref pCacheSize.GetPinnableReference(), pCacheData); + } + + /// To be documented. + public static unsafe Result GetCudaModuleCache(this NVCudaKernelLaunch thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] CudaModuleNV module, [Count(Count = 0)] Span pCacheSize, [Count(Parameter = "pCacheSize")] Span pCacheData) where T0 : unmanaged + { + // SpanOverloader + return thisApi.GetCudaModuleCache(device, module, ref pCacheSize.GetPinnableReference(), ref pCacheData.GetPinnableReference()); + } + + } +} + diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/DebugReportObjectTypeEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/DebugReportObjectTypeEXT.gen.cs index b0051f8d95..62435b10f0 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/DebugReportObjectTypeEXT.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/DebugReportObjectTypeEXT.gen.cs @@ -138,6 +138,12 @@ public enum DebugReportObjectTypeEXT : int [Obsolete("Deprecated in favour of \"AccelerationStructureNVExt\"")] [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT")] DebugReportObjectTypeAccelerationStructureNVExt = 1000165000, + [Obsolete("Deprecated in favour of \"CudaModuleNV\"")] + [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV")] + DebugReportObjectTypeCudaModuleNV = 1000307000, + [Obsolete("Deprecated in favour of \"CudaFunctionNV\"")] + [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV")] + DebugReportObjectTypeCudaFunctionNV = 1000307001, [Obsolete("Deprecated in favour of \"BufferCollectionFuchsiaExt\"")] [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT")] DebugReportObjectTypeBufferCollectionFuchsiaExt = 1000366000, @@ -225,6 +231,10 @@ public enum DebugReportObjectTypeEXT : int SamplerYcbcrConversionKhrExt = 1000156000, [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT")] AccelerationStructureNVExt = 1000165000, + [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV")] + CudaModuleNV = 1000307000, + [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV")] + CudaFunctionNV = 1000307001, [NativeName("Name", "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT")] BufferCollectionFuchsiaExt = 1000366000, } diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/ObjectType.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/ObjectType.gen.cs index 83bde256c0..bf55b8cbf0 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/ObjectType.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/ObjectType.gen.cs @@ -102,6 +102,10 @@ public enum ObjectType : int IndirectCommandsLayoutNV = 1000277000, [NativeName("Name", "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT")] PrivateDataSlotExt = 1000295000, + [NativeName("Name", "VK_OBJECT_TYPE_CUDA_MODULE_NV")] + CudaModuleNV = 1000307000, + [NativeName("Name", "VK_OBJECT_TYPE_CUDA_FUNCTION_NV")] + CudaFunctionNV = 1000307001, [NativeName("Name", "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA")] BufferCollectionFuchsia = 1000366000, [NativeName("Name", "VK_OBJECT_TYPE_MICROMAP_EXT")] diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/PhysicalDeviceSchedulingControlsFlagsARM.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/PhysicalDeviceSchedulingControlsFlagsARM.gen.cs new file mode 100644 index 0000000000..6a9546b124 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/PhysicalDeviceSchedulingControlsFlagsARM.gen.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [Flags] + [NativeName("Name", "VkPhysicalDeviceSchedulingControlsFlagsARM")] + public enum PhysicalDeviceSchedulingControlsFlagsARM : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"ShaderCoreCountArm\"")] + [NativeName("Name", "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM")] + PhysicalDeviceSchedulingControlsShaderCoreCountArm = 1, + [NativeName("Name", "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM")] + ShaderCoreCountArm = 1, + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs index 71ba35f7f9..56b740319b 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs @@ -500,6 +500,8 @@ public enum StructureType : int SubpassBeginInfoKhr = 1000109005, [NativeName("Name", "VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR")] SubpassEndInfoKhr = 1000109006, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG")] + PhysicalDeviceRelaxedLineRasterizationFeaturesImg = 1000110000, [NativeName("Name", "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR")] SharedPresentSurfaceCapabilitiesKhr = 1000111000, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR")] @@ -1178,6 +1180,16 @@ public enum StructureType : int PhysicalDeviceDiagnosticsConfigFeaturesNV = 1000300000, [NativeName("Name", "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV")] DeviceDiagnosticsConfigCreateInfoNV = 1000300001, + [NativeName("Name", "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV")] + CudaModuleCreateInfoNV = 1000307000, + [NativeName("Name", "VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV")] + CudaFunctionCreateInfoNV = 1000307001, + [NativeName("Name", "VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV")] + CudaLaunchInfoNV = 1000307002, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV")] + PhysicalDeviceCudaKernelLaunchFeaturesNV = 1000307003, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV")] + PhysicalDeviceCudaKernelLaunchPropertiesNV = 1000307004, [NativeName("Name", "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV")] QueryLowLatencySupportNV = 1000310000, [NativeName("Name", "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT")] @@ -1500,6 +1512,12 @@ public enum StructureType : int DeviceImageMemoryRequirementsKhr = 1000413003, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM")] PhysicalDeviceShaderCorePropertiesArm = 1000415000, + [NativeName("Name", "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM")] + DeviceQueueShaderCoreControlCreateInfoArm = 1000417000, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM")] + PhysicalDeviceSchedulingControlsFeaturesArm = 1000417001, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM")] + PhysicalDeviceSchedulingControlsPropertiesArm = 1000417002, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT")] PhysicalDeviceImageSlicedViewOf3DFeaturesExt = 1000418000, [NativeName("Name", "VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT")] diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/CudaFunctionCreateInfoNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaFunctionCreateInfoNV.gen.cs new file mode 100644 index 0000000000..950daa6c18 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaFunctionCreateInfoNV.gen.cs @@ -0,0 +1,85 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkCudaFunctionCreateInfoNV")] + public unsafe partial struct CudaFunctionCreateInfoNV : IChainable + { + public CudaFunctionCreateInfoNV + ( + StructureType? sType = StructureType.CudaFunctionCreateInfoNV, + void* pNext = null, + CudaModuleNV? module = null, + byte* pName = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (module is not null) + { + Module = module.Value; + } + + if (pName is not null) + { + PName = pName; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkCudaModuleNV")] + [NativeName("Type.Name", "VkCudaModuleNV")] + [NativeName("Name", "module")] + public CudaModuleNV Module; +/// + [NativeName("Type", "char*")] + [NativeName("Type.Name", "char")] + [NativeName("Name", "pName")] + public byte* PName; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.CudaFunctionCreateInfoNV; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/CudaFunctionNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaFunctionNV.gen.cs new file mode 100644 index 0000000000..61e906c550 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaFunctionNV.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkCudaFunctionNV")] + public unsafe partial struct CudaFunctionNV + { + public CudaFunctionNV + ( + ulong? handle = null + ) : this() + { + if (handle is not null) + { + Handle = handle.Value; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "")] + public ulong Handle; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/CudaLaunchInfoNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaLaunchInfoNV.gen.cs new file mode 100644 index 0000000000..f9489a15a1 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaLaunchInfoNV.gen.cs @@ -0,0 +1,195 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkCudaLaunchInfoNV")] + public unsafe partial struct CudaLaunchInfoNV : IChainable + { + public CudaLaunchInfoNV + ( + StructureType? sType = StructureType.CudaLaunchInfoNV, + void* pNext = null, + CudaFunctionNV? function = null, + uint? gridDimX = null, + uint? gridDimY = null, + uint? gridDimZ = null, + uint? blockDimX = null, + uint? blockDimY = null, + uint? blockDimZ = null, + uint? sharedMemBytes = null, + nuint? paramCount = null, + void* pParams = null, + nuint? extraCount = null, + void* pExtras = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (function is not null) + { + Function = function.Value; + } + + if (gridDimX is not null) + { + GridDimX = gridDimX.Value; + } + + if (gridDimY is not null) + { + GridDimY = gridDimY.Value; + } + + if (gridDimZ is not null) + { + GridDimZ = gridDimZ.Value; + } + + if (blockDimX is not null) + { + BlockDimX = blockDimX.Value; + } + + if (blockDimY is not null) + { + BlockDimY = blockDimY.Value; + } + + if (blockDimZ is not null) + { + BlockDimZ = blockDimZ.Value; + } + + if (sharedMemBytes is not null) + { + SharedMemBytes = sharedMemBytes.Value; + } + + if (paramCount is not null) + { + ParamCount = paramCount.Value; + } + + if (pParams is not null) + { + PParams = pParams; + } + + if (extraCount is not null) + { + ExtraCount = extraCount.Value; + } + + if (pExtras is not null) + { + PExtras = pExtras; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkCudaFunctionNV")] + [NativeName("Type.Name", "VkCudaFunctionNV")] + [NativeName("Name", "function")] + public CudaFunctionNV Function; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "gridDimX")] + public uint GridDimX; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "gridDimY")] + public uint GridDimY; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "gridDimZ")] + public uint GridDimZ; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "blockDimX")] + public uint BlockDimX; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "blockDimY")] + public uint BlockDimY; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "blockDimZ")] + public uint BlockDimZ; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "sharedMemBytes")] + public uint SharedMemBytes; +/// + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "paramCount")] + public nuint ParamCount; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pParams")] + public void* PParams; +/// + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "extraCount")] + public nuint ExtraCount; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pExtras")] + public void* PExtras; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.CudaLaunchInfoNV; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/CudaModuleCreateInfoNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaModuleCreateInfoNV.gen.cs new file mode 100644 index 0000000000..2764945aed --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaModuleCreateInfoNV.gen.cs @@ -0,0 +1,85 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkCudaModuleCreateInfoNV")] + public unsafe partial struct CudaModuleCreateInfoNV : IChainable + { + public CudaModuleCreateInfoNV + ( + StructureType? sType = StructureType.CudaModuleCreateInfoNV, + void* pNext = null, + nuint? dataSize = null, + void* pData = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (dataSize is not null) + { + DataSize = dataSize.Value; + } + + if (pData is not null) + { + PData = pData; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "size_t")] + [NativeName("Type.Name", "size_t")] + [NativeName("Name", "dataSize")] + public nuint DataSize; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pData")] + public void* PData; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.CudaModuleCreateInfoNV; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/CudaModuleNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaModuleNV.gen.cs new file mode 100644 index 0000000000..452c410624 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/CudaModuleNV.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkCudaModuleNV")] + public unsafe partial struct CudaModuleNV + { + public CudaModuleNV + ( + ulong? handle = null + ) : this() + { + if (handle is not null) + { + Handle = handle.Value; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "")] + public ulong Handle; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/DeviceQueueShaderCoreControlCreateInfoARM.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/DeviceQueueShaderCoreControlCreateInfoARM.gen.cs new file mode 100644 index 0000000000..0e23af945d --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/DeviceQueueShaderCoreControlCreateInfoARM.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkDeviceQueueShaderCoreControlCreateInfoARM")] + public unsafe partial struct DeviceQueueShaderCoreControlCreateInfoARM : IExtendsChain, IExtendsChain + { + public DeviceQueueShaderCoreControlCreateInfoARM + ( + StructureType? sType = StructureType.DeviceQueueShaderCoreControlCreateInfoArm, + void* pNext = null, + uint? shaderCoreCount = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (shaderCoreCount is not null) + { + ShaderCoreCount = shaderCoreCount.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "shaderCoreCount")] + public uint ShaderCoreCount; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.DeviceQueueShaderCoreControlCreateInfoArm; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceCudaKernelLaunchFeaturesNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceCudaKernelLaunchFeaturesNV.gen.cs new file mode 100644 index 0000000000..19252d1e29 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceCudaKernelLaunchFeaturesNV.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceCudaKernelLaunchFeaturesNV")] + public unsafe partial struct PhysicalDeviceCudaKernelLaunchFeaturesNV : IExtendsChain, IExtendsChain, IExtendsChain + { + public PhysicalDeviceCudaKernelLaunchFeaturesNV + ( + StructureType? sType = StructureType.PhysicalDeviceCudaKernelLaunchFeaturesNV, + void* pNext = null, + Bool32? cudaKernelLaunchFeatures = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (cudaKernelLaunchFeatures is not null) + { + CudaKernelLaunchFeatures = cudaKernelLaunchFeatures.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "cudaKernelLaunchFeatures")] + public Bool32 CudaKernelLaunchFeatures; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceCudaKernelLaunchFeaturesNV; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceCudaKernelLaunchPropertiesNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceCudaKernelLaunchPropertiesNV.gen.cs new file mode 100644 index 0000000000..59124d4b39 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceCudaKernelLaunchPropertiesNV.gen.cs @@ -0,0 +1,85 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceCudaKernelLaunchPropertiesNV")] + public unsafe partial struct PhysicalDeviceCudaKernelLaunchPropertiesNV : IExtendsChain, IExtendsChain + { + public PhysicalDeviceCudaKernelLaunchPropertiesNV + ( + StructureType? sType = StructureType.PhysicalDeviceCudaKernelLaunchPropertiesNV, + void* pNext = null, + uint? computeCapabilityMinor = null, + uint? computeCapabilityMajor = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (computeCapabilityMinor is not null) + { + ComputeCapabilityMinor = computeCapabilityMinor.Value; + } + + if (computeCapabilityMajor is not null) + { + ComputeCapabilityMajor = computeCapabilityMajor.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "computeCapabilityMinor")] + public uint ComputeCapabilityMinor; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "computeCapabilityMajor")] + public uint ComputeCapabilityMajor; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceCudaKernelLaunchPropertiesNV; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceRelaxedLineRasterizationFeaturesIMG.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceRelaxedLineRasterizationFeaturesIMG.gen.cs new file mode 100644 index 0000000000..1dcfca4fd5 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceRelaxedLineRasterizationFeaturesIMG.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG")] + public unsafe partial struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG : IExtendsChain, IExtendsChain, IExtendsChain + { + public PhysicalDeviceRelaxedLineRasterizationFeaturesIMG + ( + StructureType? sType = StructureType.PhysicalDeviceRelaxedLineRasterizationFeaturesImg, + void* pNext = null, + Bool32? relaxedLineRasterization = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (relaxedLineRasterization is not null) + { + RelaxedLineRasterization = relaxedLineRasterization.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "relaxedLineRasterization")] + public Bool32 RelaxedLineRasterization; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceRelaxedLineRasterizationFeaturesImg; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceSchedulingControlsFeaturesARM.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceSchedulingControlsFeaturesARM.gen.cs new file mode 100644 index 0000000000..d8b4045bfd --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceSchedulingControlsFeaturesARM.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceSchedulingControlsFeaturesARM")] + public unsafe partial struct PhysicalDeviceSchedulingControlsFeaturesARM : IExtendsChain, IExtendsChain, IExtendsChain + { + public PhysicalDeviceSchedulingControlsFeaturesARM + ( + StructureType? sType = StructureType.PhysicalDeviceSchedulingControlsFeaturesArm, + void* pNext = null, + Bool32? schedulingControls = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (schedulingControls is not null) + { + SchedulingControls = schedulingControls.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "schedulingControls")] + public Bool32 SchedulingControls; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceSchedulingControlsFeaturesArm; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceSchedulingControlsPropertiesARM.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceSchedulingControlsPropertiesARM.gen.cs new file mode 100644 index 0000000000..86757b847d --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceSchedulingControlsPropertiesARM.gen.cs @@ -0,0 +1,74 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceSchedulingControlsPropertiesARM")] + public unsafe partial struct PhysicalDeviceSchedulingControlsPropertiesARM : IExtendsChain, IExtendsChain + { + public PhysicalDeviceSchedulingControlsPropertiesARM + ( + StructureType? sType = StructureType.PhysicalDeviceSchedulingControlsPropertiesArm, + void* pNext = null, + PhysicalDeviceSchedulingControlsFlagsARM? schedulingControlsFlags = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (schedulingControlsFlags is not null) + { + SchedulingControlsFlags = schedulingControlsFlags.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkPhysicalDeviceSchedulingControlsFlagsARM")] + [NativeName("Type.Name", "VkPhysicalDeviceSchedulingControlsFlagsARM")] + [NativeName("Name", "schedulingControlsFlags")] + public PhysicalDeviceSchedulingControlsFlagsARM SchedulingControlsFlags; + + /// + StructureType IStructuredType.StructureType() + { + return SType = StructureType.PhysicalDeviceSchedulingControlsPropertiesArm; + } + + /// + unsafe BaseInStructure* IChainable.PNext + { + get => (BaseInStructure*) PNext; + set => PNext = value; + } + } +}